release 1.6.4

(to reduce risk of connection timeout)

.gitattributes

@@ -15,8 +15,12 @@
 # BINARY FILES:
 #   Disable line ending normalize on checkin.
 
+*.dll binary
+*.dylib binary
 *.gif binary
 *.jar binary
+*.lib binary
 *.png binary
 *.sketch binary
+*.so binary
 *.zip binary

.gitbugtraq

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

.github/workflows/ci.yml

@@ -0,0 +1,175 @@
+# https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
+
+name: CI
+
+on:
+  push:
+    branches:
+      - '*'
+    tags:
+      - '[0-9]*'
+  pull_request:
+    branches: 
+      - '*'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        # test against
+        # - Java 1.8 (minimum requirement)
+        # - Java 9 (first version with JPMS)
+        # - Java LTS versions (11, 17, ...)
+        # - lastest Java version(s)
+        java:
+          - 1.8
+          - 9
+          - 11  # LTS
+          - 14
+          - 15
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: gradle/wrapper-validation-action@v1
+        if: matrix.java == '1.8'
+
+      - name: Setup Java ${{ matrix.java }}
+        uses: actions/setup-java@v1
+        with:
+          java-version: ${{ matrix.java }}
+
+      - name: Cache Gradle wrapper
+        uses: actions/cache@v1
+        with:
+          path: ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-wrapper-${{ hashFiles('gradle/wrapper/gradle-wrapper.properties') }}
+
+      - name: Cache Gradle cache
+        uses: actions/cache@v2
+        with:
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle.kts') }}
+          restore-keys: ${{ runner.os }}-gradle
+
+      - name: Build with Gradle
+        run: ./gradlew build
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v2
+        if: matrix.java == '11'
+        with:
+          name: FlatLaf-build-artifacts
+          path: |
+            flatlaf-*/build/libs
+            !**/*-javadoc.jar
+            !**/*-sources.jar
+
+
+  snapshot:
+    runs-on: ubuntu-latest
+    needs: build
+    if: |
+      github.event_name == 'push' &&
+      github.ref == 'refs/heads/main' &&
+      github.repository == 'JFormDesigner/FlatLaf'
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Setup Java 11
+        uses: actions/setup-java@v1
+        with:
+          java-version: 11
+
+      - name: Cache Gradle wrapper
+        uses: actions/cache@v1
+        with:
+          path: ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-wrapper-${{ hashFiles('gradle/wrapper/gradle-wrapper.properties') }}
+
+      - name: Cache Gradle cache
+        uses: actions/cache@v2
+        with:
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle.kts') }}
+          restore-keys: ${{ runner.os }}-gradle
+
+      - name: Publish snapshot to oss.sonatype.org
+        run: ./gradlew publish :flatlaf-theme-editor:build -Dorg.gradle.internal.publish.checksums.insecure=true
+        env:
+          OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+          OSSRH_PASSWORD: ${{ secrets.OSSRH_PASSWORD }}
+
+      - name: Upload theme editor
+        uses: sebastianpopp/ftp-action@releases/v2
+        with:
+          host: ${{ secrets.FTP_SERVER }}
+          user: ${{ secrets.FTP_USERNAME }}
+          password: ${{ secrets.FTP_PASSWORD }}
+          forceSsl: true
+          localDir: "flatlaf-theme-editor/build/libs"
+          remoteDir: "snapshots"
+          options: "--only-newer --no-recursion --verbose=1"
+
+
+  release:
+    runs-on: ubuntu-latest
+    needs: build
+    if: |
+      github.event_name == 'push' &&
+      startsWith( github.ref, 'refs/tags/' ) &&
+      github.repository == 'JFormDesigner/FlatLaf'
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Setup Java 11
+        uses: actions/setup-java@v1
+        with:
+          java-version: 11
+
+      - name: Cache Gradle wrapper
+        uses: actions/cache@v1
+        with:
+          path: ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-wrapper-${{ hashFiles('gradle/wrapper/gradle-wrapper.properties') }}
+
+      - name: Cache Gradle cache
+        uses: actions/cache@v2
+        with:
+          path: ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle.kts') }}
+          restore-keys: ${{ runner.os }}-gradle
+
+      - name: Release a new stable version to Maven Central
+        run: ./gradlew publish :flatlaf-demo:build :flatlaf-theme-editor:build -Drelease=true
+        env:
+          OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+          OSSRH_PASSWORD: ${{ secrets.OSSRH_PASSWORD }}
+          SIGNING_KEY:      ${{ secrets.SIGNING_KEY }}
+          SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }}
+
+      - name: Upload demo
+        uses: sebastianpopp/ftp-action@releases/v2
+        with:
+          host: ${{ secrets.FTP_SERVER }}
+          user: ${{ secrets.FTP_USERNAME }}
+          password: ${{ secrets.FTP_PASSWORD }}
+          forceSsl: true
+          localDir: "flatlaf-demo/build/libs"
+          remoteDir: "."
+          options: "--only-newer --no-recursion --verbose=1"
+
+      - name: Upload theme editor
+        uses: sebastianpopp/ftp-action@releases/v2
+        with:
+          host: ${{ secrets.FTP_SERVER }}
+          user: ${{ secrets.FTP_USERNAME }}
+          password: ${{ secrets.FTP_PASSWORD }}
+          forceSsl: true
+          localDir: "flatlaf-theme-editor/build/libs"
+          remoteDir: "."
+          options: "--only-newer --no-recursion --verbose=1"

.github/workflows/natives.yml

@@ -0,0 +1,58 @@
+# https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
+
+name: Native Libraries
+
+on:
+    push:
+        branches:
+            - '*'
+        tags:
+            - '[0-9]*'
+        paths:
+            - 'flatlaf-natives/flatlaf-natives-windows/**'
+            - '.github/workflows/natives.yml'
+    pull_request:
+        branches:
+            - '*'
+        paths:
+            - 'flatlaf-natives/flatlaf-natives-windows/**'
+            - '.github/workflows/natives.yml'
+
+jobs:
+    Windows:
+        runs-on: windows-latest
+
+        steps:
+            - uses: actions/checkout@v2
+
+            - uses: gradle/wrapper-validation-action@v1
+
+            - name: Setup Java 1.8
+              uses: actions/setup-java@v1
+              with:
+                  java-version: 1.8
+
+            - name: Cache Gradle wrapper
+              uses: actions/cache@v1
+              with:
+                  path: ~/.gradle/wrapper
+                  key: ${{ runner.os }}-gradle-wrapper-${{ hashFiles('gradle/wrapper/gradle-wrapper.properties') }}
+
+            - name: Cache Gradle cache
+              uses: actions/cache@v2
+              with:
+                  path: |
+                    ~/.gradle/caches
+                    !~/.gradle/caches/modules-2/modules-2.lock
+                  key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle.kts') }}
+                  restore-keys: ${{ runner.os }}-gradle
+
+            - name: Build with Gradle
+              run: ./gradlew :flatlaf-natives-windows:build
+
+            - name: Upload artifacts
+              uses: actions/upload-artifact@v2
+              with:
+                  name: FlatLaf-natives-windows-build-artifacts
+                  path: |
+                      flatlaf-natives/flatlaf-natives-windows/build

.gitignore

@@ -9,3 +9,5 @@ out/
 *.iml
 *.ipr
 *.iws
+.vs/
+.vscode/

.travis.yml

@@ -1,39 +0,0 @@
-language: java
-sudo: false
-
-jdk:
-  - openjdk8
-  - openjdk9
-  - openjdk11
-  - openjdk13
-
-before_cache:
-  - rm -f  $HOME/.gradle/caches/modules-2/modules-2.lock
-  - rm -fr $HOME/.gradle/caches/*/plugin-resolution/
-cache:
-  directories:
-    - $HOME/.gradle/caches/
-    - $HOME/.gradle/wrapper/
-
-before_install:
-  - ./gradlew --version
-  - java -version
-
-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,902 @@
 FlatLaf Change Log
 ==================
 
+## 1.6.4
+
+#### Fixed bugs
+
+- ComboBox: Fixed regression in FlatLaf 1.6.3 that makes selected item invisible
+  in popup list if `DefaultListCellRenderer` is used as renderer. If using
+  default renderer, it works. (issue #426)
+
+
+## 1.6.3
+
+#### Fixed bugs
+
+- ComboBox (not editable): Fixed regression in FlatLaf 1.6.2 that may display
+  text in non-editable combo boxes in bold. (issue #423)
+- Tree: Fixed editing cell issue with custom cell renderer and cell editor that
+  use same component for rendering and editing. (issue #385)
+
+
+## 1.6.2
+
+#### Fixed bugs
+
+- ComboBox (not editable): Fixed background painted outside of border if round
+  edges are enabled (client property `JComponent.roundRect` is `true`). (similar
+  to issue #382; regression since fixing #330 in FlatLaf 1.4)
+- ComboBox: Fixed `NullPointerException`, which may occur under special
+  circumstances. (issue #408)
+- Table: Do not select text in cell editor when it gets focus (when
+  `JTable.surrendersFocusOnKeystroke` is `true`) and
+  `TextComponent.selectAllOnFocusPolicy` is `once` (the default) or `always`.
+  (issue #395)
+- Linux: Fixed NPE when using `java.awt.TrayIcon`. (issue #405)
+- FileChooser: Workaround for crash on Windows with Java 17 32-bit (disabled
+  Windows icons). Java 17 64-bit is not affected. (issue #403)
+- Native window decorations: Fixed layout loop, which may occur under special
+  circumstances and slows down the application. (issue #420)
+
+
+## 1.6.1
+
+#### Fixed bugs
+
+- Native window decorations: Catch `UnsatisfiedLinkError` when trying to load
+  `jawt.dll` to avoid an application crash (Java 8 on Windows 10 only).
+
+
+## 1.6
+
+#### New features and improvements
+
+- InternalFrame: Double-click on icon in internal frame title bar now closes the
+  internal frame. (issue #374)
+- IntelliJ Themes: Removed deprecated `install()` methods.
+
+#### Fixed bugs
+
+- Menus: Fixed missing modifiers flags in `ActionEvent` (e.g. `Ctrl` key
+  pressed) when running in Java 9+ on Linux, macOS. Occurs also on Windows in
+  large popup menus that do not fit into the window. (issue #371; regression
+  since FlatLaf 1.3)
+- OptionPane: Fixed `OptionPane.sameSizeButtons`, which did not work as expected
+  when setting to `false`.
+- OptionPane: Fixed rendering of longer HTML text if it is passed as
+  `StringBuilder`, `StringBuffer`, or any other object that returns HTML text in
+  method `toString()`. (similar to issue #12)
+- ComboBox: Fixed popup border painting on HiDPI screens (e.g. at 150% scaling).
+- ComboBox: Fixed popup location if shown above of combo box (Java 8 only).
+- ComboBox (editable): Fixed wrong border of internal text field under special
+  circumstances.
+- Spinner: Fixed painting of border corners on left side. (issue #382;
+  regression since fixing #330 in FlatLaf 1.4)
+- TableHeader: Do not show resize cursor for last column if resizing last column
+  is not possible because auto resize mode of table is not off. (issue #332)
+- TableHeader: Fixed missing trailing vertical separator line if used in upper
+  left corner of scroll pane. (issue #332)
+- TextField, FormattedTextField, PasswordField and ComboBox: Fixed alignment of
+  placeholder text in right-to-left component orientation.
+- Slider: Fixed calculation of baseline, which was wrong under some
+  circumstances.
+
+
+## 1.5
+
+#### New features and improvements
+
+- SwingX: Added search and clear icons to `JXSearchField`. (issue #359)
+
+#### Fixed bugs
+
+- Button and TextComponent: Do not apply minimum width/height if margins are
+  set. (issue #364)
+- ComboBox and Spinner: Limit arrow button width if component has large
+  preferred height. (issue #361)
+- FileChooser: Fixed missing (localized) texts when FlatLaf is loaded in special
+  classloader (e.g. plugin system in Apache NetBeans).
+- InternalFrame: Limit internal frame bounds to parent bounds on resize. Also
+  honor maximum size of internal frame. (issue #362)
+- Popup: Fixed incorrectly placed drop shadow for medium-weight popups in
+  maximized windows. (issue #358)
+- Native window decorations (Windows 10 only):
+  - Fixed occasional application crash in `flatlaf-windows.dll`. (issue #357)
+  - When window is initially shown, fill background with window background color
+    (instead of white), which avoids flickering in dark themes. (issue 339)
+  - When resizing a window at the right/bottom edge, then first fill the new
+    space with the window background color (instead of black) before the layout
+    is updated.
+  - When resizing a window at the left/top edge, then first fill the new space
+    with the window background color (instead of garbage) before the layout is
+    updated.
+
+
+## 1.4
+
+#### New features and improvements
+
+- TextField, FormattedTextField and PasswordField: Support adding extra padding.
+  (set client property `JTextField.padding` to `Insets`).
+- PasswordField: UI delegate `FlatPasswordFieldUI` now extends `FlatTextFieldUI`
+  (instead of `BasicPasswordFieldUI`) to avoid duplicate code and for easier
+  extensibility.
+- Table and PopupFactory: Use `StackWalker` in Java 9+ for better performance.
+  (issue #334)
+- ToolBar: Paint focus indicator for focused button in toolbar. (issue #346)
+- ToolBar: Support focusable buttons in toolbar (set UI value
+  `ToolBar.focusableButtons` to `true`). (issue #346)
+
+#### Fixed bugs
+
+- ComboBox (editable) and Spinner: Increased size of internal text field to the
+  component border so that it behaves like plain text field (mouse click to left
+  of text now positions caret to first character instead of opening ComboBox
+  popup; mouse cursor is now of type "text" within the whole component, except
+  for arrow buttons). (issue #330)
+- ComboBox (not editable): Increased size of internal renderer pane to the
+  component border so that it can paint within the whole component. Also
+  increase combo box size if a custom renderer uses a border with insets that
+  are larger than the default combo box padding (`2,6,2,6`).
+- Fixed component heights at `1.25x`, `1.75x` and `2.25x` scaling factors (Java
+  8 only) so that Button, ComboBox, Spinner and TextField components (including
+  subclasses) have same heights. This increases heights of Button and TextField
+  components by:
+  - `2px` at `1.75x` in **Light** and **Dark** themes
+  - `2px` at `1.25x` and `2.25x` in **IntelliJ** and **Darcula** themes
+- OptionPane: Do not make child components, which are derived from `JPanel`,
+  non-opaque. (issue #349)
+- OptionPane: Align wrapped lines to the right if component orientation is
+  right-to-left. (issue #350)
+- PasswordField: Caps lock icon no longer painted over long text. (issue #172)
+- PasswordField: Paint caps lock icon on left side in right-to-left component
+  orientation.
+- Window decorations: Window title bar width is no longer considered when
+  calculating preferred/minimum width of window. (issue #351)
+
+
+## 1.3
+
+#### New features and improvements
+
+- TextComponents, ComboBox and Spinner: Support different background color when
+  component is focused (use UI values `TextField.focusedBackground`,
+  `PasswordField.focusedBackground`, `FormattedTextField.focusedBackground`,
+  `TextArea.focusedBackground`, `TextPane.focusedBackground`,
+  `EditorPane.focusedBackground`, `ComboBox.focusedBackground`,
+  `ComboBox.buttonFocusedBackground`, `ComboBox.popupBackground` and
+  `Spinner.focusedBackground`). (issue #335)
+
+#### Fixed bugs
+
+- Fixed white lines at bottom and right side of window (in dark themes on HiDPI
+  screens with scaling enabled).
+- ScrollBar: Fixed left/top arrow icon location (if visible). (issue #329)
+- Spinner: Fixed up/down arrow icon location.
+- ToolTip: Fixed positioning of huge tooltips. (issue #333)
+
+
+## 1.2
+
+#### New features and improvements
+
+- Renamed `Flat*Laf.install()` methods to `Flat*Laf.setup()` to avoid confusion
+  with `UIManager.installLookAndFeel(LookAndFeelInfo info)`. The old
+  `Flat*Laf.install()` methods are still there, but marked as deprecated. They
+  will be removed in a future version.
+- Button and ToggleButton: Support borderless button style (set client property
+  `JButton.buttonType` to `borderless`). (PR #276)
+- ComboBox: Support using as cell renderer (e.g. in `JTable`).
+- DesktopPane: Improved layout of iconified internal frames in dock:
+  - Always placed at bottom-left in desktop pane.
+  - Newly iconified frames are added to the right side of the dock.
+  - If frame is deiconified, dock is compacted (icons move to the left).
+  - If dock is wider than desktop width, additional rows are used.
+  - If desktop pane is resized, layout of dock is updated.
+- TableHeader: Moved table header column border painting from
+  `FlatTableHeaderUI` to new border `FlatTableHeaderBorder` to improve
+  compatibility with custom table header implementations. (issue #228)
+- Linux: Enable text anti-aliasing if no Gnome or KDE Desktop properties are
+  available. (issue #218)
+- IntelliJ Themes: Added "Material Theme UI Lite / GitHub Dark" theme.
+- JIDE Common Layer: Improved support for `JideTabbedPane`. (PR #306)
+- Extras: `FlatSVGIcon` improvements:
+  - Each icon can now have its own color filter. (PR #303)
+  - Use mapper function in color filter to dynamically map colors. (PR #303)
+  - Color filter supports light and dark themes.
+  - Getters for icon name, classloader, etc.
+- Extras: UI Inspector: Show class hierarchies when pressing <kbd>Alt</kbd> key
+  and prettified class names (dimmed package name).
+- Extras: `FlatSVGUtils.createWindowIconImages()` now returns a single
+  multi-resolution image that creates requested image sizes on demand from SVG
+  (only on Windows with Java 9+).
+
+#### Fixed bugs
+
+- CheckBox and RadioButton: Do not fill background if used as cell renderer,
+  except if cell is selected or has different background color. (issue #311)
+- DesktopPane:
+  - Fixed missing preview of iconified internal frames in dock when using a
+    custom desktop manager. (PR #294)
+  - Fixed incomplete preview of iconified internal frames in dock when switching
+    LaF.
+  - On HiDPI screens, use high-resolution images for preview of iconified
+    internal frames in dock.
+- PopupFactory: Fixed occasional `NullPointerException` in
+  `FlatPopupFactory.fixToolTipLocation()`. (issue #305)
+- Tree: Fill cell background if
+  `DefaultTreeCellRenderer.setBackgroundNonSelectionColor(Color)` was used.
+  (issue #322)
+- IntelliJ Themes: Fixed background colors of DesktopPane and DesktopIcon in all
+  themes.
+- Native window decorations:
+  - Fixed slow application startup under particular conditions. (e.g. incomplete
+    custom JRE) (issue #319)
+  - Fixed occasional double window title bar when creating many frames or
+    dialogs. (issue #315)
+  - Fixed broken maximizing window (under special conditions) when restoring
+    frame state at startup.
+  - Title icon: For multi-resolution images now use `getResolutionVariant(width,
+    height)` (instead of `getResolutionVariants()`) to allow creation of
+    requested size on demand. This also avoids creation of all resolution
+    variants.
+  - Double-click at upper-left corner of maximized frame did not close window.
+    (issue #326)
+- Linux: Fixed/improved detection of user font settings. (issue #309)
+
+
+## 1.1.2
+
+#### New features and improvements
+
+- Native window decorations: Added API to check whether current platform
+  supports window decorations (`FlatLaf.supportsNativeWindowDecorations()`) and
+  to toggle window decorations of all windows
+  (`FlatLaf.setUseNativeWindowDecorations(boolean)`).
+- Native window decorations: Support changing title bar background and
+  foreground colors per window. (set client properties
+  `JRootPane.titleBarBackground` and `JRootPane.titleBarForeground` on root pane
+  to a `java.awt.Color`).
+
+#### Fixed bugs
+
+- Native window decorations: Fixed loading of native library when using Java
+  Platform Module System (JPMS) for application. (issue #289)
+- Native window decorations: Removed superfluous pixel-line at top of screen
+  when window is maximized. (issue #296)
+- Window decorations: Fixed random window title bar background in cases were
+  background is not filled by custom window or root pane components and unified
+  background is enabled.
+- IntelliJ Themes: Fixed window title bar background if unified background is
+  enabled.
+- IntelliJ Themes: Fixed system colors.
+- Button and ToggleButton: Do not paint background of disabled (and unselected)
+  toolBar buttons. (issue #292; regression since fixing #112)
+- ComboBox and Spinner: Fixed too wide arrow button if component is higher than
+  preferred. (issue #302)
+- SplitPane: `JSplitPane.setContinuousLayout(false)` did not work. (issue #301)
+- TabbedPane: Fixed NPE when creating/modifying in another thread. (issue #299)
+- Fixed crash when running in Webswing. (issue #290)
+
+
+## 1.1.1
+
+#### New features and improvements
+
+- Native window decorations: Support disabling native window decorations per
+  window. (set client property `JRootPane.useWindowDecorations` on root pane to
+  `false`).
+- Support running on WinPE. (issue #279)
+
+#### Fixed bugs
+
+- Native window decorations: Fixed missing animations when minimizing,
+  maximizing or restoring a window using window title bar buttons. (issue #282)
+- Native window decorations: Fixed broken maximizing window when restoring frame
+  state at startup. (issue #283)
+- Native window decorations: Fixed double window title bar when first disposing
+  a window with `frame.dispose()` and then showing it again with
+  `frame.setVisible(true)`. (issue #277)
+- Custom window decorations: Fixed NPE in `FlatTitlePane.findHorizontalGlue()`.
+  (issue #275)
+- Custom window decorations: Fixed right aligned progress bar in embedded menu
+  bar was overlapping window title. (issue #272)
+- Fixed missing focus indicators in heavy-weight popups. (issue #273)
+- InternalFrame: Fixed translucent internal frame menu bar background if
+  `TitlePane.unifiedBackground` is `true`. (issue #274)
+- Extras: UI Inspector: Fixed `InaccessibleObjectException` when running in Java 16.
+
+
+## 1.1
+
+#### New features and improvements
+
+- Windows 10 only:
+  - Native window decorations for Windows 10 enables dark frame/dialog title bar
+    and embedded menu bar with all JREs, while still having native Windows 10
+    border drop shadows, resize behavior, window snapping and system window
+    menu. (PR #267)
+  - Custom window decorations: Support right aligned components in `JFrame`
+    title bar with embedded menu bar (using `Box.createHorizontalGlue()`). (PR
+    #268)
+  - Custom window decorations: Improved centering of window title with embedded
+    menu bar. (PR #268; issue #252)
+  - Custom window decorations: Support unified backgrounds for window title bar,
+    menu bar and main content. If enabled with `UIManager.put(
+    "TitlePane.unifiedBackground", true );` then window title bar and menu bar
+    use same background color as main content. (PR #268; issue #254)
+- JIDE Common Layer: Support `JideButton`, `JideLabel`, `JideSplitButton`,
+  `JideToggleButton` and `JideToggleSplitButton`.
+- JIDE Common Layer: The library on Maven Central no longer depends on
+  `com.jidesoft:jide-oss:3.6.18` to avoid problems when another JIDE library
+  should be used. (issue #270)
+- SwingX: The library on Maven Central no longer depends on
+  `org.swinglabs.swingx:swingx-all:1.6.5-1` to avoid problems when another
+  SwingX library should be used.
+- Support running in [JetBrains Projector](https://jetbrains.com/projector/).
+
+#### Fixed bugs
+
+- IntelliJ Themes: Fixed text color of CheckBoxMenuItem and RadioButtonMenuItem
+  in all "Arc" themes. (issue #259)
+
+
+## 1.0
+
+#### New features and improvements
+
+- Extras: UI Inspector: Tooltip is no longer limited to window bounds.
+
+#### Fixed bugs
+
+- TabbedPane: Custom `TabbedPane.selectedForeground` color did not work when
+  `TabbedPane.foreground` has also custom color. (issue #257)
+- FileChooser: Fixed display of date in details view if current user is selected
+  in "Look in" combobox. (Windows 10 only; issue #249)
+- Table: Fixed wrong grid line thickness in dragged column on HiDPI screens on
+  Java 9+. (issue #236)
+- PopupFactory: Fixed `NullPointerException` when `PopupFactory.getPopup()` is
+  invoked with parameter `owner` set to `null`.
+
+
+## 1.0-rc3
+
+#### New features and improvements
+
+- Extras:
+  - UI Inspector: Use HTML in tooltip. Display color value in same format as
+    used in FlatLaf properties files. Added color preview.
+
+#### Fixed bugs
+
+- Label and ToolTip: Fixed font sizes for `<code>`, `<kbd>`, `<big>`, `<small>`
+  and `<samp>` tags in HTML text.
+- Fixed color of `<address>` tag in HTML text.
+- IntelliJ Themes: Fixed table header background when dragging column in "Dark
+  Flat" and "Light Flat" themes.
+- CheckBox: Fixed background of check boxes in JIDE `CheckBoxTree`. (regression
+  in 1.0-rc2)
+
+
+## 1.0-rc2
+
+#### New features and improvements
+
+- Button:
+  - In "Flat Light" theme, use a slightly thinner border for focused buttons
+    (because they already have light blue background).
+  - In "Flat Dark" theme, use slightly wider border for focused buttons.
+- CheckBox and RadioButton: In "Flat Dark" theme, use blueish background for
+  focused components.
+- Tree: Support disabling wide selection per component. (set client property
+  `JTree.wideSelection` to `false`). (PR #245)
+- Tree: Support disabling selection painting per component. Then the tree cell
+  renderer is responsible for selection painting. (set client property
+  `JTree.paintSelection` to `false`).
+- JIDE Common Layer: Support `JidePopupMenu`.
+
+#### Fixed bugs
+
+- Button: Fixed behavior of <kbd>Enter</kbd> key on focused button on Windows
+  and Linux, which now clicks the focused button (instead of the default
+  button).
+  - On Windows, this is a regression in 1.0-rc1.
+  - On macOS, the <kbd>Enter</kbd> key always clicks the default button, which
+    is the platform behavior.
+  - On all platforms, the default button can be always clicked with
+    <kbd>Ctrl+Enter</kbd> keys, even if another button is focused.
+- CheckBox and RadioButton: Fill component background as soon as background
+  color is different to default background color, even if component is not
+  opaque (which is the default). This paints selection if using the component as
+  cell renderer in Table, Tree or List.
+- TextComponents: Border of focused non-editable text components had wrong
+  color.
+- Custom window decorations: Fixed top window border in dark themes when running
+  in JetBrains Runtime.
+
+
+## 1.0-rc1
+
+#### New features and improvements
+
+- Button: Disabled `Button.defaultButtonFollowsFocus` on Windows (as on other
+  platforms). If you like to keep the old behavior in your application, use:
+  `if(SystemInfo.isWindows)
+  UIManager.put("Button.defaultButtonFollowsFocus",true);`.
+- ComboBox, Spinner and SplitPaneDivider: Added pressed feedback to arrow
+  buttons.
+- Slider: Support per component custom thumb and track colors via
+  `JSlider.setForeground(Color)` and `JSlider.setBackground(Color)`.
+- Slider: Improved thumb hover and pressed colors.
+- TextComponent: Clip placeholder text if it does not fit into visible area. (PR
+  #229)
+- macOS: Improved font rendering on macOS when using JetBrains Runtime. (PRs
+  #237, #239 and #241)
+- Extras: UI defaults inspector:
+  - Support embedding UI defaults inspector panel into any window. See
+    `FlatUIDefaultsInspector.createInspectorPanel()`.
+  - Copy selected keys and values into clipboard via context menu.
+  - Support wildcard matching in filter (`*` matches any number of characters,
+    `?` matches a single character, `^` beginning of line, `$` end of line).
+- IntelliJ Themes:
+  - Added hover and pressed feedback to Button, CheckBox, RadioButton and
+    ToggleButton. (issue #176)
+  - Added "Material Theme UI Lite / Moonlight" theme.
+  - Updated "Dracula", "Gradianto" and "Material Theme UI Lite" themes.
+
+#### Fixed bugs
+
+- Button and ToggleButton: Threat Unicode surrogate character pair as single
+  character and make button square. (issue #234)
+- Button and ToggleButton: ToolBar buttons now respect explicitly set background
+  color. If no background color is set, then the button background is not
+  painted anymore. (issue #191)
+- ToggleButton: Tab style buttons (client property `JButton.buttonType` is
+  `tab`) now respect explicitly set background color.
+- TabbedPane: Fixed `IndexOutOfBoundsException` when using tooltip text on close
+  buttons and closing last/rightmost tab. (issue #235)
+- TabbedPane: Fixed scrolling tabs with touchpads and high-resolution mouse
+  wheels.
+- Extras: Added missing export of package
+  `com.formdev.flatlaf.extras.components` to Java 9 module descriptor.
+- JIDE Common Layer:
+  - Invoke `LookAndFeelFactory.installJideExtension()` when using FlatLaf UI
+    delegates. (issue #230)
+  - RangeSlider: Fixed slider focused colors in IntelliJ themes.
+- IntelliJ Themes:
+  - Fixed menu item check colors.
+  - Fixed `MenuItem.underlineSelectionColor`.
+  - Fixed List, Tree and Table `selectionInactiveForeground` in light Arc
+    themes.
+  - Fixed List and Table background colors in Material UI Lite themes.
+  - Fixed menu accelerator colors in Monocai theme. (issue #243)
+
+
+## 0.46
+
+#### New features and improvements
+
+- Slider and JIDE RangeSlider: Clicking on track now immediately moves the thumb
+  to mouse location and starts dragging the thumb. Use `UIManager.put(
+  "Slider.scrollOnTrackClick", true )` to enable old behavior that scrolls the
+  thumb when clicking on track.
+- Slider: Snap to ticks is now done while dragging the thumb. Use
+  `UIManager.put( "Slider.snapToTicksOnReleased", true )` to enable old behavior
+  that snaps to ticks on mouse released.
+- Extras: Added standard component extension classes that provides easy access
+  to FlatLaf specific client properties (see package
+  `com.formdev.flatlaf.extras.components`).
+- Extras: Renamed tri-state check box class from
+  `com.formdev.flatlaf.extras.TriStateCheckBox` to
+  `com.formdev.flatlaf.extras.components.FlatTriStateCheckBox`. Also
+  changed/improved API and added javadoc.
+- Extras: Renamed SVG utility class from `com.formdev.flatlaf.extras.SVGUtils`
+  to `com.formdev.flatlaf.extras.FlatSVGUtils`.
+- IntelliJ Themes: Added flag whether a theme is dark to
+  `FlatAllIJThemes.INFOS`. (issue #221)
+- JIDE Common Layer: Support `TristateCheckBox`.
+
+
+#### Fixed bugs
+
+- Slider: Fixed painting of colored track if `JSlider.inverted` is `true`.
+- Table and TableHeader: Fixed missing right vertical grid line if using table
+  as row header in scroll pane. (issues #152 and #46)
+- TableHeader: Fixed position of column separators in right-to-left component
+  orientation.
+- ToolTip: Fixed drop shadow for wide tooltips on Windows and Java 9+. (issue
+  #224)
+- SwingX: Fixed striping background highlighting color (e.g. alternating table
+  rows) in dark themes.
+- Fixed: If text antialiasing is disabled (in OS system settings or via
+  `-Dawt.useSystemAAFontSettings=off`), then some components still did use
+  antialiasing to render text (not-editable ComboBox, ProgressBar, Slider,
+  TabbedPane and multiline ToolTip). (issue #227)
+
+
+## 0.45
+
+#### New features and improvements
+
+- Slider: New design, added hover and pressed feedback and improved customizing.
+  (PR #214)
+- JIDE Common Layer: Support `RangeSlider`. (PR #209)
+- IntelliJ Themes:
+  - Added "Gradianto Nature Green" theme.
+  - Updated "Arc Dark", "Cyan", "Dark purple", "Gradianto", "Gray", "Gruvbox"
+    and "One Dark" themes.
+- TabbedPane: Support hiding tab area if it contains only one tab. (set client
+  property `JTabbedPane.hideTabAreaWithOneTab` to `true`)
+- MenuBar: Support different underline menu selection style UI defaults for
+  `MenuBar` and `MenuItem`. (PR #217; issue #216)
+
+
+#### Fixed bugs
+
+- Table: Do not paint last vertical grid line if auto-resize mode is not off.
+  (issue #46)
+- Table: Fixed unstable grid line thickness when scaled on HiDPI screens. (issue
+  #152)
+- TabbedPane: No longer add (internal) tab close button component as child to
+  `JTabbedPane`. (issue #219)
+- Custom window decorations: Title bar was not hidden if window is in
+  full-screen mode. (issue #212)
+
+
+## 0.44
+
+#### New features and improvements
+
+- TabbedPane: In scroll tab layout, added "Show Hidden Tabs" button to trailing
+  side of tab area. If pressed, it shows a popup menu that contains (partly)
+  hidden tabs and selecting one activates that tab. (PR #190; issue #40)
+- TabbedPane: Support forward/backward scroll arrow buttons on both sides of tab
+  area. Backward button on left side, forward button on right side. Not
+  applicable scroll buttons are hidden. (PR #211; issue #40)
+- TabbedPane: Support specifying default tab layout policy for all tabbed panes
+  in the application via UI value `TabbedPane.tabLayoutPolicy`. E.g. invoke
+  `UIManager.put( "TabbedPane.tabLayoutPolicy", "scroll" );` to use scroll
+  layout.
+- TabbedPane: Support tab scrolling with mouse wheel (in scroll tab layout). (PR
+  #187; issue #40)
+- TabbedPane: Repeat scrolling as long as scroll arrow buttons are pressed. (PR
+  #187; issue #40)
+- TabbedPane: Support adding custom components to left and right sides of tab
+  area. (set client property `JTabbedPane.leadingComponent` or
+  `JTabbedPane.trailingComponent` to a `java.awt.Component`) (PR #192; issue
+  #40)
+- TabbedPane: Support closable tabs. (PR #193; issues #31 and #40)
+- TabbedPane: Support minimum or maximum tab widths. (set client property
+  `JTabbedPane.minimumTabWidth` or `JTabbedPane.maximumTabWidth` to an integer)
+  (PR #199)
+- TabbedPane: Support alignment of tab area. (set client property
+  `JTabbedPane.tabAreaAlignment` to `"leading"`, `"trailing"`, `"center"` or
+  `"fill"`) (PR #199)
+- TabbedPane: Support horizontal alignment of tab title and icon. (set client
+  property `JTabbedPane.tabAlignment` to `SwingConstants.LEADING`,
+  `SwingConstants.TRAILING` or `SwingConstants.CENTER`)
+- TabbedPane: Support equal and compact tab width modes. (set client property
+  `JTabbedPane.tabWidthMode` to `"preferred"`, `"equal"` or `"compact"`) (PR
+  #199)
+- TabbedPane: Support left, right, top and bottom tab icon placement. (set
+  client property `JTabbedPane.tabIconPlacement` to `SwingConstants.LEADING`,
+  `SwingConstants.TRAILING`, `SwingConstants.TOP` or `SwingConstants.BOTTOM`)
+  (PR #199)
+- Support painting separator line between window title and content (use UI value
+  `TitlePane.borderColor`). (issue #184)
+- Extras: `FlatSVGIcon` now allows specifying icon width and height in
+  constructors. (issue #196)
+- SplitPane: Hide not applicable expand/collapse buttons. Added tooltips to
+  expand/collapse buttons. (issue #198)
+- SplitPane: Added grip to divider. Can be disabled with `UIManager.put(
+  "SplitPaneDivider.style", "plain" )`. (issue #179)
+
+
+#### Fixed bugs
+
+- Custom window decorations: Not visible menu bar is now ignored in layout.
+- Popups using `JToolTip` components did not respect their location. (issue
+  #188; regression in 0.42 in fix for #164)
+- IntelliJ Themes: Added suffix "(Material)" to names of all Material UI Lite
+  themes to avoid duplicate theme names. (issue #201)
+- Extras: `FlatSVGIcon` icons were not painted in disabled labels and disabled
+  tabs. (issue #205)
+
+
+## 0.43
+
+#### New features and improvements
+
+- TabbedPane: Made tabs separator color lighter in dark themes so that it is
+  easier to recognize the tabbed pane.
+- TabbedPane: Added top and bottom tab insets to avoid that large tab icons are
+  painted over active tab underline.
+- TabbedPane: Support hiding separator between tabs and content area (set client
+  property `JTabbedPane.showContentSeparator` to `false`).
+- CheckBoxMenuItem and RadioButtonMenuItem: Improved checkmark background colors
+  of selected menu items that have also an icon. This makes it is easier to
+  recognize selected menu items.
+- Windows: Made scaling compatible with Windows OS scaling, which distinguish
+  between "screen scaling" and "text scaling". (issue #175)
+
+#### Fixed bugs
+
+- ComboBox: If using own `JTextField` as editor, default text field border is
+  now removed to avoid duplicate border.
+- ComboBox: Limit popup width to screen width for very long items. (issue #182)
+- FileChooser: Fixed localizing special Windows folders (e.g. "Documents") and
+  enabled hiding known file extensions (if enabled in Windows Explorer). (issue
+  #178)
+- Spinner: Fixed `NullPointerException` in case that arrow buttons were removed
+  to create button-less spinner. (issue #181)
+
+
+## 0.42
+
+#### New features and improvements
+
+- Demo: Improved "SplitPane & Tabs" and "Data Components" tabs.
+- Demo: Menu items "File > Open" and "File > Save As" now show file choosers.
+- InternalFrame: Support draggable border for resizing frame inside of the
+  visible frame border. (issue #121)
+- `FlatUIDefaultsInspector` added (see [FlatLaf Extras](flatlaf-extras)). A
+  simple UI defaults inspector that shows a window with all UI defaults used in
+  current theme (look and feel).
+- Made disabled text color slightly lighter in dark themes for better
+  readability. (issue #174)
+- PasswordField: Support disabling Caps Lock warning icon. (issue #172)
+
+#### Fixed bugs
+
+- TextComponents: Fixed text color of disabled text components in dark themes.
+- Custom window decorations: Fixed wrong window placement when moving window to
+  another screen with different scaling factor. (issue #166)
+- Custom window decorations: Fixed wrong window bounds when resizing window to
+  another screen with different scaling factor. (issue #166)
+- Fixed occasional wrong positioning of heavy weight popups when using multiple
+  screens with different scaling factors. (issue #166)
+- ToolTip: Avoid that tooltip hides owner component. (issue #164)
+
+
+## 0.41
+
+#### New features and improvements
+
+- Added API to register packages or folders where FlatLaf searches for
+  application specific properties files with custom UI defaults (see
+  `FlatLaf.registerCustomDefaultsSource(...)` methods).
+- Demo: Show hint popups to guide users to some features of the FlatLaf Demo
+  application.
+- Extras: `FlatSVGIcon` now allows specifying `ClassLoader` that is used to load
+  SVG file. (issue #163)
+- Smoother transition from old to new theme, independent of UI complexity, when
+  using animated theme change (see [FlatLaf Extras](flatlaf-extras)).
+
+#### Fixed bugs
+
+- Button: "selected" state was not shown. (issue #161)
+- TextArea: Update background color property if enabled or editable state
+  changes in the same way as Swing does it for all other text components. (issue
+  #147)
+- Demo: Fixed restoring last used theme on startup. (regression in 0.39)
+- Custom window decorations: Fixed iconify, maximize and close icon colors if
+  window is inactive.
+- Custom window decorations: Fixed title pane background color in IntelliJ
+  themes if window is inactive.
+- Fixed sub-pixel text rendering in animated theme change (see
+  [FlatLaf Extras](flatlaf-extras)).
+
+#### Other Changes
+
+- Extras: Updated dependency
+  [svgSalamander](https://github.com/JFormDesigner/svgSalamander) to version
+  1.1.2.3.
+
+
+## 0.40
+
+#### New features
+
+- Table: Detect whether component is used in cell editor and automatically
+  disable round border style and reduce cell editor outer border width (used for
+  focus indicator) to zero. (issue #148)
+- ComboBox, Spinner and TextField: Support disabling round border style per
+  component, if globally enabled (set client property `JComponent.roundRect` to
+  `false`). (issue #148)
+
+#### Fixed bugs
+
+- Custom window decorations: Embedded menu bar did not always respond to mouse
+  events after adding menus and when running in JetBrains Runtime. (issue #151)
+- IntelliJ Themes: Fixed NPE in Solarized themes on scroll bar hover.
+
+
+## 0.39
+
+#### New features
+
+- Animated theme change (see [FlatLaf Extras](flatlaf-extras)). Used in Demo.
+- Demo: Added combo box above themes list to show only light or dark themes.
+- IntelliJ Themes:
+  - Added "Arc Dark", "Arc Dark - Orange", "Carbon" and "Cobalt 2" themes.
+  - Replaced "Solarized" themes with much better ones from 4lex4.
+  - Updated "Arc", "One Dark" and "Vuesion" themes.
+- ScrollPane: Enable/disable smooth scrolling per component if client property
+  "JScrollPane.smoothScrolling" is set to a `Boolean` on `JScrollPane`.
+- ScrollBar: Increased minimum thumb size on macOS and Linux from 8 to 18
+  pixels. On Windows, it is now 10 pixels. (issue #131)
+- Button: Support specifying button border width.
+- ComboBox: Changed maximum row count of popup list to 15 (was 20). Set UI value
+  `ComboBox.maximumRowCount` to any integer to use a different value.
+
+#### Fixed bugs
+
+- Custom window decorations: Fixed maximized window bounds when programmatically
+  maximizing window. E.g. restoring window state at startup. (issue #129)
+- InternalFrame: Title pane height was too small when iconify, maximize and
+  close buttons are hidden. (issue #132)
+- ToolTip: Do not show empty tooltip component if tooltip text is an empty
+  string. (issue #134)
+- ToolTip: Fixed truncated text in HTML formatted tooltip on HiDPI displays.
+  (issue #142)
+- ComboBox: Fixed width of popup, which was too small if popup is wider than
+  combo box and vertical scroll bar is visible. (issue #137)
+- MenuItem on macOS: Removed plus characters from accelerator text and made
+  modifier key order conform with macOS standard. (issue #141)
+- FileChooser: Fixed too small text field when renaming a file/directory in Flat
+  IntelliJ/Darcula themes. (issue #143)
+- IntelliJ Themes: Fixed text colors in ProgressBar. (issue #138)
+
+
+## 0.38
+
+- Hide focus indicator when window is inactive.
+- Custom window decorations: Improved/fixed window border color in dark themes.
+- Custom window decorations: Hide window border if window is maximized.
+- Custom window decorations: Center title if menu bar is embedded.
+- Custom window decorations: Cursor of components (e.g. TextField) was not
+  changed. (issue #125)
+- CheckBox: Fixed colors in light IntelliJ themes. (issue #126; regression in
+  0.37)
+- InternalFrame: Use default icon in internal frames. (issue #122)
+
+
+## 0.37
+
+- Custom window decorations (Windows 10 only; PR #108; issues #47 and #82)
+  support:
+  - dark window title panes
+  - embedding menu bar into window title pane
+  - native Windows 10 borders and behavior when running in
+    [JetBrains Runtime 11](https://confluence.jetbrains.com/display/JBR/JetBrains+Runtime)
+    or later (the JRE that IntelliJ IDEA uses)
+- CheckBox and RadioButton: Support changing selected icon style from outline to
+  filled (as in FlatLaf IntelliJ theme) with `UIManager.put(
+  "CheckBox.icon.style", "filled" );`.
+- Button and ToggleButton: Support disabled background color (use UI values
+  `Button.disabledBackground` and `ToggleButton.disabledBackground`). (issue
+  #112)
+- Button and ToggleButton: Support making buttons square (set client property
+  `JButton.squareSize` to `true`). (issue #118)
+- ScrollBar: Support pressed track, thumb and button colors (use UI values
+  `ScrollBar.pressedTrackColor`, `ScrollBar.pressedThumbColor` and
+  `ScrollBar.pressedButtonBackground`). (issue #115)
+- ComboBox: Support changing arrow button style (set UI value
+  `ComboBox.buttonStyle` to `auto` (default), `button` or `none`). (issue #114)
+- Spinner: Support changing arrows button style (set UI value
+  `Spinner.buttonStyle` to `button` (default) or `none`).
+- TableHeader: Support top/bottom/left positioned sort arrow when using
+  [Glazed Lists](https://github.com/glazedlists/glazedlists). (issue #113)
+- Button, CheckBox, RadioButton and ToggleButton: Do not paint focus indicator
+  if `AbstractButton.isFocusPainted()` returns `false`.
+- ComboBox: Increase maximum row count of popup list to 20 (was 8). Set UI value
+  `ComboBox.maximumRowCount` to any integer to use a different value.
+- Fixed/improved vertical position of text when scaled on HiDPI screens on
+  Windows.
+- IntelliJ Themes: Updated Gradianto Themes.
+- IntelliJ Themes: Fixed menu bar and menu item margins in all Material UI Lite
+  themes.
+
+
+## 0.36
+
+- ScrollBar: Made styling more flexible by supporting insets and arc for track
+  and thumb. (issue #103)
+- ScrollBar: Use round thumb on macOS and Linux to make it look similar to
+  native platform scroll bars. (issue #103)
+- ComboBox: Minimum width is now 72 pixels (was ~50 for non-editable and ~130
+  for editable comboboxes).
+- ComboBox: Support custom borders in combobox editors. (issue #102)
+- Button: Support non-square icon-only buttons. (issue #110)
+- Ubuntu Linux: Fixed poorly rendered font. (issue #105)
+- macOS Catalina: Use Helvetica Neue font.
+- `FlatInspector` added (see [FlatLaf Extras](flatlaf-extras)).
+
+
+## 0.35
+
+- Added drop shadows to popup menus, combobox popups, tooltips and internal
+  frames. (issue #94)
+- Support different component border colors to indicate errors, warnings or
+  custom state (set client property `JComponent.outline` to `error`, `warning`
+  or any `java.awt.Color`).
+- Button and ToggleButton: Support round button style (set client property
+  `JButton.buttonType` to `roundRect`).
+- ComboBox, Spinner and TextField: Support round border style (set client
+  property `JComponent.roundRect` to `true`).
+- Paint nicely rounded buttons, comboboxes, spinners and text fields when
+  setting `Button.arc`, `Component.arc` or `TextComponent.arc` to a large value
+  (e.g. 1000).
+- Added Java 9 module descriptor to `flatlaf-extras-<version>.jar` and
+  `flatlaf-swingx-<version>.jar`.
+- CheckBox and RadioButton: Flag `opaque` is no longer ignored when checkbox or
+  radio button is used as table cell renderer. (issue #77)
+- FileChooser: Use system icons. (issue #100)
+- FileChooser: Fixed missing labels in file chooser when running on Java 9 or
+  later. (issue #98)
+- PasswordField: Do not apply minimum width if `columns` property is greater
+  than zero.
+
+
+## 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

README.md

@@ -11,19 +11,18 @@ scales on **HiDPI** displays and runs on Java 8 or newer.
 The look is heavily inspired by **Darcula** and **IntelliJ** themes from
 IntelliJ IDEA 2019.2+ and uses almost the same colors and icons.
 
-![Flat Light Demo](images/FlatLightDemo.png)
+![Flat Light](images/flat_light.png)
 
-![Flat Dark Demo](images/FlatDarkDemo.png)
+![Flat Dark](images/flat_dark.png)
 
 
 IntelliJ Platform Themes
 ------------------------
 
-FlatLaf can use 3rd party themes created for IntelliJ Platform:
+FlatLaf can use 3rd party themes created for IntelliJ Platform (see
+[IntelliJ Themes Pack](flatlaf-intellij-themes)):
 
-![Cyan Light Demo](images/CyanLightDemo.png)
-
-![Dark Purple Demo](images/DarkPurpleDemo.png)
+![IntelliJ Platform Themes](images/intellij_platform_themes.png)
 
 
 Demo
@@ -38,7 +37,7 @@ Requires Java 8 or newer.
 Download
 --------
 
-FlatLaf binaries are available on **JCenter** and **Maven Central**.
+FlatLaf binaries are available on **Maven Central**.
 
 If you use Maven or Gradle, add a dependency with following coordinates to your
 build script:
@@ -49,16 +48,16 @@ build script:
 
 Otherwise download `flatlaf-<version>.jar` here:
 
-[![Download](https://api.bintray.com/packages/jformdesigner/flatlaf/flatlaf/images/download.svg)](https://bintray.com/jformdesigner/flatlaf/flatlaf/_latestVersion)
+[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.formdev/flatlaf/badge.svg?style=flat-square&color=007ec6)](https://maven-badges.herokuapp.com/maven-central/com.formdev/flatlaf)
 
 
 ### Snapshots
 
-FlatLaf snapshot binaries are available 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
+FlatLaf snapshot binaries are available on
+[Sonatype OSSRH](https://oss.sonatype.org/content/repositories/snapshots/com/formdev/flatlaf/).
+To access the latest snapshot, change the FlatLaf version in your dependencies
 to `<version>-SNAPSHOT` (e.g. `0.27-SNAPSHOT`) and add the repository
-`https://oss.jfrog.org/artifactory/oss-snapshot-local` to your build (see
+`https://oss.sonatype.org/content/repositories/snapshots/` to your build (see
 [Maven](https://maven.apache.org/guides/mini/guide-multiple-repositories.html)
 and
 [Gradle](https://docs.gradle.org/current/userguide/declaring_repositories.html#sec:declaring_custom_repository)
@@ -68,39 +67,136 @@ docs).
 Addons
 ------
 
-- [SwingX](flatlaf-swingx)
-- [JIDE Common Layer](flatlaf-jide-oss)
+- [IntelliJ Themes Pack](flatlaf-intellij-themes) - bundles many popular
+  open-source 3rd party themes
+- [Extras](flatlaf-extras) - SVG icon, tri-state check box, UI inspectors, and
+  more
+- [SwingX](flatlaf-swingx) - support for SwingX components
+- [JIDE Common Layer](flatlaf-jide-oss) - support for JIDE Common Layer
+  components
 
 
-Projects using FlatLaf
-----------------------
+Getting started
+---------------
 
-- [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)
-- [j-lawyer](https://github.com/jlawyerorg/j-lawyer-org)
-- [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)
-- and more...
+To use FlatLaf, add following code to your main method before you create any
+Swing component:
 
+~~~java
+FlatLightLaf.setup();
 
-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/)
+// create UI here...
+~~~
 
 
 Documentation
 -------------
 
 For more information and documentation visit
-[FlatLaf Home](https://www.formdev.com/flatlaf/)
+[FlatLaf Home](https://www.formdev.com/flatlaf/):
+
+- [Themes](https://www.formdev.com/flatlaf/themes/)
+- [Customizing](https://www.formdev.com/flatlaf/customizing/)
+- [How to Customize](https://www.formdev.com/flatlaf/how-to-customize/)
+- [Properties Files](https://www.formdev.com/flatlaf/properties-files/)
+- [Client Properties](https://www.formdev.com/flatlaf/client-properties/)
+- [System Properties](https://www.formdev.com/flatlaf/system-properties/)
+
+
+Buzz
+----
+
+- [What others say about FlatLaf on Twitter](https://twitter.com/search?f=live&q=flatlaf)
+- [FlatLaf 1.0 announcement on Reddit](https://www.reddit.com/r/java/comments/lsbcwe/flatlaf_10_swing_look_and_feel/)
+- [FlatLaf announcement on Reddit](https://www.reddit.com/r/java/comments/dl0hu3/flatlaf_flat_look_and_feel/)
+
+
+Applications using FlatLaf
+--------------------------
+
+- [Apache NetBeans](https://netbeans.apache.org/) 11.3 - IDE for Java, PHP, HTML
+  and much more
+- [jclasslib bytecode viewer](https://github.com/ingokegel/jclasslib) 5.5
+- [KeyStore Explorer](https://keystore-explorer.org/) 5.4.3
+- ![New](images/new.svg)
+  [install4j](https://www.ej-technologies.com/products/install4j/overview.html)
+  9.0 (**commercial**) - the powerful multi-platform Java installer builder
+- ![New](images/new.svg) [DbVisualizer](https://www.dbvis.com/) 12.0
+  (**commercial**) - the universal database tool for developers, analysts and
+  DBAs
+- ![New](images/new.svg) [MagicPlot](https://magicplot.com/) 3.0
+  (**commercial**) - Software for nonlinear fitting, plotting and data analysis
+- ![New](images/new.svg)
+  [Thermo-Calc](https://thermocalc.com/products/thermo-calc/) 2021a
+  (**commercial**) - Thermodynamics and Properties Software
+- [OWASP ZAP](https://www.zaproxy.org/) 2.10 - the worlds most widely used web
+  app scanner
+- ![New](images/new.svg)
+  [Burp Suite Professional and Community Edition](https://portswigger.net/burp/pro)
+  2020.11.2 (**commercial**) - the leading software for web security testing
+- ![New](images/new.svg)
+  [BurpCustomizer](https://github.com/CoreyD97/BurpCustomizer) - adds more
+  FlatLaf themes to Burp Suite
+- [JOSM](https://josm.openstreetmap.de/) - an extensible editor for
+  [OpenStreetMap](https://www.openstreetmap.org/) (requires FlatLaf JOSM plugin)
+- [jAlbum](https://jalbum.net/) 21 (**commercial**) - creates photo album
+  websites
+- [XMLmind XML Editor](https://www.xmlmind.com/xmleditor/) 9.3 (**commercial**)
+- [Total Validator](https://www.totalvalidator.com/) 15 (**commercial**) -
+  checks your website
+- [j-lawyer](https://github.com/jlawyerorg/j-lawyer-org) - Kanzleisoftware
+- [MegaMek](https://github.com/MegaMek/megamek) v0.47.4 and
+  [MekHQ](https://github.com/MegaMek/mekhq) v0.47.5 - a turn-based sci-fi board
+  game
+- [GUIslice Builder](https://github.com/ImpulseAdventure/GUIslice-Builder)
+  0.13.b024 - GUI builder for
+  [GUIslice](https://github.com/ImpulseAdventure/GUIslice), a lightweight GUI
+  framework for embedded displays
+- [Rest Suite](https://github.com/supanadit/restsuite) - Rest API testing
+- [ControllerBuddy](https://github.com/bwRavencl/ControllerBuddy) - advanced
+  gamepad mapping software
+- [SpringRemote](https://github.com/HaleyWang/SpringRemote) - remote Linux SSH
+  connections manager
+- [jEnTunnel](https://github.com/ggrandes/jentunnel) - manage SSH Tunnels made
+  easy
+- [mendelson AS2](https://sourceforge.net/projects/mec-as2/),
+  [AS4](https://sourceforge.net/projects/mendelson-as4/) and
+  [OFTP2](https://sourceforge.net/projects/mendelson-oftp2/) (open-source) and
+  [mendelson AS2](https://mendelson-e-c.com/as2/),
+  [AS4](https://mendelson-e-c.com/as4/) and
+  [OFTP2](https://mendelson-e-c.com/oftp2) (**commercial**)
+- ![New](images/new.svg) [IGMAS+](https://www.gfz-potsdam.de/igmas) -
+  Interactive Gravity and Magnetic Application System
+- [MeteoInfo](https://github.com/meteoinfo/MeteoInfo) 2.2 - GIS and scientific
+  computation environment for meteorological community
+- [lsfusion platform](https://github.com/lsfusion/platform) 4 - information
+  systems development platform
+- [JPass](https://github.com/gaborbata/jpass) - password manager with strong
+  encryption
+- [Jes - Die Java-E<>R](https://www.jes-eur.de)
+- [Mapton](https://mapton.org/) 2.0
+  ([source code](https://github.com/trixon/mapton)) - some kind of map
+  application (based on NetBeans platform)
+- [Pseudo Assembler IDE](https://github.com/tomasz-herman/PseudoAssemblerIDE) -
+  IDE for Pseudo-Assembler
+- [Linotte](https://github.com/cpc6128/LangageLinotte) 3.1 - French programming
+  language created to learn programming
+- [MEKA](https://github.com/Waikato/meka) 1.9.3 - multi-label classifiers and
+  evaluation procedures using the Weka machine learning framework
+- [Shutter Encoder](https://www.shutterencoder.com/) 14.2
+  ([source code](https://github.com/paulpacifico/shutter-encoder)) -
+  professional video converter and compression tool (screenshots show **old**
+  look)
+- [Sound Analysis](https://github.com/tomasz-herman/SoundAnalysis) - analyze
+  sound files in time or frequency domain
+- [RemoteLight](https://github.com/Drumber/RemoteLight) - multifunctional LED
+  control software
+- [ThunderFocus](https://github.com/marcocipriani01/ThunderFocus) -
+  Arduino-based telescope focuser
+- [Novel-Grabber](https://github.com/Flameish/Novel-Grabber) - download novels
+  from any webnovel and lightnovel site
+- [lectureStudio](https://www.lecturestudio.org/) 4.3.1060 - digitize your
+  lectures with ease
+- [Android Tool](https://github.com/fast-geek/Android-Tool) - makes popular adb
+  and fastboot commands easier to use
+- and more...

build.gradle.kts

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-val releaseVersion = "0.30"
-val developmentVersion = "0.31-SNAPSHOT"
+val releaseVersion = "1.6.4"
+val developmentVersion = "2.0-SNAPSHOT"
 
 version = if( java.lang.Boolean.getBoolean( "release" ) ) releaseVersion else developmentVersion
 
@@ -23,7 +23,7 @@ allprojects {
 	version = rootProject.version
 
 	repositories {
-		jcenter()
+		mavenCentral()
 	}
 }
 
@@ -40,17 +40,6 @@ 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 {
@@ -58,19 +47,35 @@ allprojects {
 			targetCompatibility = "1.8"
 
 			options.encoding = "ISO-8859-1"
+			options.isDeprecation = false
 		}
 
 		withType<Jar>().configureEach {
 			// manifest for all created JARs
-			manifest.attributes(mapOf(
+			manifest.attributes(
 				"Implementation-Vendor" to "FormDev Software GmbH",
-				"Implementation-Copyright" to "Copyright (C) ${java.time.LocalDate.now().year} FormDev Software GmbH. All rights reserved.",
-				"Implementation-Version" to project.version))
+				"Implementation-Copyright" to "Copyright (C) 2019-${java.time.LocalDate.now().year} FormDev Software GmbH. All rights reserved.",
+				"Implementation-Version" to project.version
+			)
 
 			// add META-INF/LICENSE to all created JARs
-			from("${rootDir}/LICENSE") {
-				into("META-INF")
+			from( "${rootDir}/LICENSE" ) {
+				into( "META-INF" )
 			}
 		}
+
+		withType<Javadoc>().configureEach {
+			options {
+				this as StandardJavadocDocletOptions
+
+				title = "${project.name} $version"
+				header = title
+				isUse = true
+				tags = listOf( "uiDefault", "clientProperty" )
+				addStringOption( "Xdoclint:all,-missing", "-Xdoclint:all,-missing" )
+				links( "https://docs.oracle.com/en/java/javase/11/docs/api/" )
+			}
+			isFailOnError = false
+		}
 	}
 }

buildSrc/build.gradle.kts

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

buildSrc/src/main/java/ReorderJarEntries.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.file.Files;
+import java.nio.file.StandardOpenOption;
+import java.util.function.Predicate;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+import java.util.zip.ZipOutputStream;
+
+/**
+ * Reorders entries in a JAR file so that .properties files are placed before .class files,
+ * which is necessary to workaround an issue in NetBeans 11.3 (and older).
+ * See issues #13 and #93.
+ *
+ * @author Karl Tauber
+ */
+public class ReorderJarEntries
+{
+	public static void reorderJarEntries( File jarFile )
+		throws IOException
+	{
+		ByteArrayOutputStream outStream = new ByteArrayOutputStream( (int) jarFile.length() + 1000 );
+
+		try( ZipOutputStream zipOutStream = new ZipOutputStream( outStream ) ) {
+			// 1st pass: copy .properties files
+			copyFiles( zipOutStream, jarFile, name -> name.endsWith( ".properties" ) );
+
+			// 2st pass: copy other files
+			copyFiles( zipOutStream, jarFile, name -> !name.endsWith( ".properties" ) );
+		}
+
+		// replace JAR
+		Files.write( jarFile.toPath(), outStream.toByteArray(),
+			StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING );
+	}
+
+	private static void copyFiles( ZipOutputStream dest, File jarFile, Predicate<String> filter )
+		throws IOException
+	{
+		try( ZipInputStream zipInputStream = new ZipInputStream( new FileInputStream( jarFile ) ) ) {
+			ZipEntry entry;
+			while( (entry = zipInputStream.getNextEntry()) != null ) {
+				if( filter.test( entry.getName() ) ) {
+					dest.putNextEntry( entry );
+					copyFile( zipInputStream, dest );
+				}
+			}
+		}
+	}
+
+	private static void copyFile( InputStream src, OutputStream dest )
+		throws IOException
+	{
+		byte[] buf = new byte[8*1024];
+		int len;
+		while( (len = src.read( buf )) > 0 )
+			dest.write( buf, 0, len );
+		dest.flush();
+	}
+}

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+plugins {
+	java
+}
+
+if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
+	sourceSets {
+		create( "java9" ) {
+			java {
+				setSrcDirs( listOf( "src/main/java9" ) )
+			}
+		}
+	}
+
+	dependencies {
+		add( "java9Compile", sourceSets.main.get().output )
+	}
+
+	tasks {
+		named<JavaCompile>( "compileJava9Java" ) {
+			sourceCompatibility = "9"
+			targetCompatibility = "9"
+		}
+
+		jar {
+			manifest.attributes( "Multi-Release" to "true" )
+
+			into( "META-INF/versions/9" ) {
+				from( sourceSets["java9"].output )
+			}
+		}
+	}
+}

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

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+open class ModuleInfoExtension {
+	var paths: ArrayList<String> = ArrayList()
+
+	fun dependsOn( vararg paths: String ) {
+		this.paths.addAll( paths )
+	}
+}
+
+val extension = project.extensions.create<ModuleInfoExtension>( "flatlafModuleInfo" )
+
+
+plugins {
+	java
+}
+
+if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
+	sourceSets {
+		create( "module-info" ) {
+			java {
+				// include "src/main/java" and "src/main/java9" here to get compile errors if classes are
+				// used from other modules that are not specified in module dependencies
+				setSrcDirs( listOf( "src/main/module-info", "src/main/java", "src/main/java9" ) )
+
+				// exclude Java 8 source file if an equally named Java 9+ source file exists
+				exclude {
+					if( it.isDirectory )
+						return@exclude false
+					val java9file = file( "${projectDir}/src/main/java9/${it.path}" )
+					java9file.exists() && java9file != it.file
+				}
+			}
+		}
+	}
+
+	tasks {
+		named<JavaCompile>( "compileModuleInfoJava" ) {
+			sourceCompatibility = "9"
+			targetCompatibility = "9"
+
+			dependsOn( extension.paths )
+
+			options.compilerArgs.add( "--module-path" )
+			options.compilerArgs.add( configurations.runtimeClasspath.get().asPath
+				+ File.pathSeparator + configurations.compileClasspath.get().asPath )
+		}
+
+		jar {
+			manifest.attributes( "Multi-Release" to "true" )
+
+			into( "META-INF/versions/9" ) {
+				from( sourceSets["module-info"].output ) {
+					include( "module-info.class" )
+				}
+			}
+		}
+	}
+}

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

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+open class PublishExtension {
+	var artifactId: String? = null
+	var name: String? = null
+	var description: String? = null
+}
+
+val extension = project.extensions.create<PublishExtension>( "flatlafPublish" )
+
+
+plugins {
+	`maven-publish`
+	signing
+}
+
+publishing {
+	publications {
+		create<MavenPublication>( "maven" ) {
+			afterEvaluate {
+				artifactId = extension.artifactId
+			}
+			groupId = "com.formdev"
+
+			from( components["java"] )
+
+			pom {
+				afterEvaluate {
+					this@pom.name.set( extension.name )
+					this@pom.description.set( extension.description )
+				}
+				url.set( "https://github.com/JFormDesigner/FlatLaf" )
+
+				licenses {
+					license {
+						name.set( "The Apache License, Version 2.0" )
+						url.set( "https://www.apache.org/licenses/LICENSE-2.0.txt" )
+					}
+				}
+
+				developers {
+					developer {
+						name.set( "Karl Tauber" )
+						organization.set( "FormDev Software GmbH" )
+						organizationUrl.set( "https://www.formdev.com/" )
+					}
+				}
+
+				scm {
+					connection.set( "scm:git:git://github.com/JFormDesigner/FlatLaf.git" )
+					url.set( "https://github.com/JFormDesigner/FlatLaf" )
+				}
+
+				issueManagement {
+					system.set( "GitHub" )
+					url.set( "https://github.com/JFormDesigner/FlatLaf/issues" )
+				}
+			}
+		}
+	}
+
+	repositories {
+		maven {
+			name = "OSSRH"
+
+			val releasesRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
+			val snapshotsRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots/"
+			url = uri( if( java.lang.Boolean.getBoolean( "release" ) ) releasesRepoUrl else snapshotsRepoUrl )
+
+			credentials {
+				// get from gradle.properties
+				val ossrhUsername: String? by project
+				val ossrhPassword: String? by project
+
+				username = System.getenv( "OSSRH_USERNAME" ) ?: ossrhUsername
+				password = System.getenv( "OSSRH_PASSWORD" ) ?: ossrhPassword
+			}
+		}
+	}
+}
+
+signing {
+	// get from gradle.properties
+	val signingKey: String? by project
+	val signingPassword: String? by project
+
+	val key = System.getenv( "SIGNING_KEY" ) ?: signingKey
+	val password = System.getenv( "SIGNING_PASSWORD" ) ?: signingPassword
+
+	useInMemoryPgpKeys( key, password )
+	sign( publishing.publications["maven"] )
+}
+
+// disable signing of snapshots
+tasks.withType<Sign>().configureEach {
+	onlyIf { java.lang.Boolean.getBoolean( "release" ) }
+}

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

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

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

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

flatlaf-core/build.gradle.kts

@@ -16,150 +16,57 @@
 
 plugins {
 	`java-library`
-	`maven-publish`
-	id( "com.jfrog.bintray" )
-	id( "com.jfrog.artifactory" )
+	`flatlaf-module-info`
+	`flatlaf-java9`
+	`flatlaf-publish`
 }
 
-if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
-	sourceSets {
-		create( "module-info" ) {
-			java {
-				// include "src/main/java" here to get compile errors if classes are
-				// used from other modules that are not specified in module dependencies
-				setSrcDirs( listOf( "src/main/module-info", "src/main/java" ) )
-			}
-		}
-	}
+dependencies {
+	testImplementation( "org.junit.jupiter:junit-jupiter-api:5.7.2" )
+	testImplementation( "org.junit.jupiter:junit-jupiter-params" )
+	testRuntimeOnly( "org.junit.jupiter:junit-jupiter-engine" )
+}
+
+java {
+	withSourcesJar()
+	withJavadocJar()
 }
 
 tasks {
-	assemble {
-		dependsOn(
-			"sourcesJar",
-			"javadocJar"
-		)
+	compileJava {
+		// generate JNI headers
+		options.headerOutputDirectory.set( buildDir.resolve( "generated/jni-headers" ) )
 	}
 
-	if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
-		named<JavaCompile>( "compileModuleInfoJava" ) {
-			sourceCompatibility = "9"
-			targetCompatibility = "9"
-		}
+	processResources {
+		// build native libraries
+		dependsOn( ":flatlaf-natives-windows:assemble" )
 	}
 
 	jar {
 		archiveBaseName.set( "flatlaf" )
 
-		if( JavaVersion.current() >= JavaVersion.VERSION_1_9 ) {
-			from( sourceSets["module-info"].output ) {
-				include( "module-info.class" )
-			}
+		doLast {
+			ReorderJarEntries.reorderJarEntries( outputs.files.singleFile );
 		}
 	}
 
-	javadoc {
-		options {
-			this as StandardJavadocDocletOptions
-			tags = listOf( "uiDefault", "clientProperty" )
-			addStringOption( "Xdoclint:all,-missing", "-Xdoclint:all,-missing" )
-		}
-		isFailOnError = false
-	}
-
-	register( "sourcesJar", Jar::class ) {
+	named<Jar>( "sourcesJar" ) {
 		archiveBaseName.set( "flatlaf" )
-		archiveClassifier.set( "sources" )
-
-		from( sourceSets.main.get().allJava )
 	}
 
-	register( "javadocJar", Jar::class ) {
+	named<Jar>( "javadocJar" ) {
 		archiveBaseName.set( "flatlaf" )
-		archiveClassifier.set( "javadoc" )
+	}
 
-		from( javadoc )
+	test {
+		useJUnitPlatform()
+		testLogging.exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
 	}
 }
 
-publishing {
-	publications {
-		create<MavenPublication>( "maven" ) {
-			artifactId = "flatlaf"
-			groupId = "com.formdev"
-
-			from( components["java"] )
-
-			artifact( tasks["sourcesJar"] )
-			artifact( tasks["javadocJar"] )
-
-			pom {
-				name.set( "FlatLaf" )
-				description.set( "Flat Look and Feel" )
-				url.set( "https://github.com/JFormDesigner/FlatLaf" )
-
-				licenses {
-					license {
-						name.set( "The Apache License, Version 2.0" )
-						url.set( "https://www.apache.org/licenses/LICENSE-2.0.txt" )
-					}
-				}
-
-				developers {
-					developer {
-						name.set( "Karl Tauber" )
-						organization.set( "FormDev Software GmbH" )
-						organizationUrl.set( "https://www.formdev.com/" )
-					}
-				}
-
-				scm {
-					url.set( "https://github.com/JFormDesigner/FlatLaf" )
-				}
-			}
-		}
-	}
-}
-
-bintray {
-	user = rootProject.extra["bintray.user"] as String?
-	key = rootProject.extra["bintray.key"] as String?
-
-	setPublications( "maven" )
-
-	with( pkg ) {
-		repo = "flatlaf"
-		name = "flatlaf"
-		setLicenses( "Apache-2.0" )
-		vcsUrl = "https://github.com/JFormDesigner/FlatLaf"
-
-		with( version ) {
-			name = project.version.toString()
-		}
-
-		publish = 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" )
-	} )
+flatlafPublish {
+	artifactId = "flatlaf"
+	name = "FlatLaf"
+	description = "Flat Look and Feel"
 }

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

@@ -19,18 +19,29 @@ package com.formdev.flatlaf;
 import java.awt.Color;
 import java.util.Objects;
 import javax.swing.JComponent;
+import javax.swing.SwingConstants;
 
 /**
+ * Defines/documents own client properties used in FlatLaf.
+ *
  * @author Karl Tauber
  */
 public interface FlatClientProperties
 {
+	//---- JButton ------------------------------------------------------------
+
 	/**
 	 * Specifies type of a button.
 	 * <p>
 	 * <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_SQUARE} and {@link #BUTTON_TYPE_HELP}
+	 * <strong>Allowed Values</strong>
+	 *     {@link #BUTTON_TYPE_SQUARE},
+	 *     {@link #BUTTON_TYPE_ROUND_RECT},
+	 *     {@link #BUTTON_TYPE_TAB},
+	 *     {@link #BUTTON_TYPE_HELP},
+	 *     {@link #BUTTON_TYPE_TOOLBAR_BUTTON} or
+	 *     {@link #BUTTON_TYPE_BORDERLESS}
 	 */
 	String BUTTON_TYPE = "JButton.buttonType";
 
@@ -43,6 +54,15 @@ public interface FlatClientProperties
 	 */
 	String BUTTON_TYPE_SQUARE = "square";
 
+	/**
+	 * Paint the button with round edges.
+	 * <p>
+	 * <strong>Components</strong> {@link javax.swing.JButton} and {@link javax.swing.JToggleButton}
+	 *
+	 * @see #BUTTON_TYPE
+	 */
+	String BUTTON_TYPE_ROUND_RECT = "roundRect";
+
 	/**
 	 * Paint the toggle button in tab style.
 	 * <p>
@@ -61,6 +81,25 @@ public interface FlatClientProperties
 	 */
 	String BUTTON_TYPE_HELP = "help";
 
+	/**
+	 * Paint the button in toolbar style.
+	 * <p>
+	 * <strong>Components</strong> {@link javax.swing.JButton} and {@link javax.swing.JToggleButton}
+	 *
+	 * @see #BUTTON_TYPE
+	 */
+	String BUTTON_TYPE_TOOLBAR_BUTTON = "toolBarButton";
+
+	/**
+	 * Paint the button without a border in the unfocused state.
+	 * <p>
+	 * <strong>Components</strong> {@link javax.swing.JButton} and {@link javax.swing.JToggleButton}
+	 *
+	 * @see #BUTTON_TYPE
+	 * @since 1.2
+	 */
+	String BUTTON_TYPE_BORDERLESS = "borderless";
+
 	/**
 	 * Specifies selected state of a checkbox.
 	 * <p>
@@ -77,11 +116,22 @@ public interface FlatClientProperties
 	 */
 	String SELECTED_STATE_INDETERMINATE = "indeterminate";
 
+	/**
+	 * Specifies whether the button preferred size will be made square (quadratically).
+	 * <p>
+	 * <strong>Components</strong> {@link javax.swing.JButton} and {@link javax.swing.JToggleButton}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 */
+	String SQUARE_SIZE = "JButton.squareSize";
+
+	//---- JComponent ---------------------------------------------------------
+
 	/**
 	 * 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>
+	 * <strong>Component</strong> {@link javax.swing.JButton}, {@link javax.swing.JToggleButton},
+	 * {@link javax.swing.JComboBox}, {@link javax.swing.JSpinner} and {@link javax.swing.text.JTextComponent}<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer}
 	 */
 	String MINIMUM_WIDTH = "JComponent.minimumWidth";
 
@@ -89,10 +139,91 @@ public interface FlatClientProperties
 	 * 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>
+	 * <strong>Value type</strong> {@link java.lang.Integer}
 	 */
 	String MINIMUM_HEIGHT = "JComponent.minimumHeight";
 
+	/**
+	 * Paint the component with round edges.
+	 * <p>
+	 * <strong>Components</strong> {@link javax.swing.JComboBox}, {@link javax.swing.JSpinner},
+	 * {@link javax.swing.JTextField}, {@link javax.swing.JFormattedTextField} and {@link javax.swing.JPasswordField}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 */
+	String COMPONENT_ROUND_RECT = "JComponent.roundRect";
+
+	/**
+	 * Specifies the outline color of the component border.
+	 * <p>
+	 * <strong>Components</strong> {@link javax.swing.JButton}, {@link javax.swing.JComboBox},
+	 * {@link javax.swing.JFormattedTextField}, {@link javax.swing.JPasswordField},
+	 * {@link javax.swing.JScrollPane}, {@link javax.swing.JSpinner},
+	 * {@link javax.swing.JTextField} and {@link javax.swing.JToggleButton}<br>
+	 * <strong>Value type</strong> {@link java.lang.String} or {@link java.awt.Color} or {@link java.awt.Color}[2]<br>
+	 * <strong>Allowed Values</strong>
+	 *     {@link #OUTLINE_ERROR},
+	 *     {@link #OUTLINE_WARNING},
+	 *     any color (type {@link java.awt.Color}) or
+	 *     an array of two colors (type {@link java.awt.Color}[2]) where the first color
+	 *     is for focused state and the second for unfocused state
+	 */
+	String OUTLINE = "JComponent.outline";
+
+	/**
+	 * Paint the component border in another color (usually reddish) to indicate an error.
+	 *
+	 * @see #OUTLINE
+	 */
+	String OUTLINE_ERROR = "error";
+
+	/**
+	 * Paint the component border in another color (usually yellowish) to indicate a warning.
+	 *
+	 * @see #OUTLINE
+	 */
+	String OUTLINE_WARNING = "warning";
+
+	/**
+	 * Specifies a callback that is invoked to check whether a component is permanent focus owner.
+	 * Used to paint focus indicators.
+	 * <p>
+	 * May be useful in special cases for custom components.
+	 * <p>
+	 * Use a {@link java.util.function.Predicate} that receives the component as parameter:
+	 * <pre>{@code
+	 * myComponent.putClientProperty( "JComponent.focusOwner",
+	 *     (Predicate<JComponent>) c -> {
+	 *         return ...; // check here
+	 *     } );
+	 * }</pre>
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JComponent}<br>
+	 * <strong>Value type</strong> {@link java.util.function.Predicate}&lt;javax.swing.JComponent&gt;
+	 */
+	String COMPONENT_FOCUS_OWNER = "JComponent.focusOwner";
+
+	//---- Popup --------------------------------------------------------------
+
+	/**
+	 * Specifies whether a drop shadow is painted if the component is shown in a popup
+	 * or if the component is the owner of another component that is shown in a popup.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JComponent}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 */
+	String POPUP_DROP_SHADOW_PAINTED = "Popup.dropShadowPainted";
+
+	/**
+	 * Specifies whether a heavy weight window should be used if the component is shown in a popup
+	 * or if the component is the owner of another component that is shown in a popup.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JComponent}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 */
+	String POPUP_FORCE_HEAVY_WEIGHT = "Popup.forceHeavyWeight";
+
+	//---- JProgressBar -------------------------------------------------------
+
 	/**
 	 * Specifies whether the progress bar has always the larger height even if no string is painted.
 	 * <p>
@@ -109,6 +240,72 @@ public interface FlatClientProperties
 	 */
 	String PROGRESS_BAR_SQUARE = "JProgressBar.square";
 
+	//---- JRootPane ----------------------------------------------------------
+
+	/**
+	 * Specifies whether FlatLaf native window decorations should be used
+	 * for {@code JFrame} or {@code JDialog}.
+	 * <p>
+	 * Setting this enables/disables using FlatLaf native window decorations
+	 * for the window that contains the root pane.
+	 * <p>
+	 * This client property has lower priority than system property
+	 * {@link FlatSystemProperties#USE_WINDOW_DECORATIONS}, but higher priority
+	 * than UI default {@code TitlePane.useWindowDecorations}.
+	 * <p>
+	 * (requires Window 10)
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 *
+	 * @since 1.1.1
+	 */
+	String USE_WINDOW_DECORATIONS = "JRootPane.useWindowDecorations";
+
+	/**
+	 * Specifies whether the menu bar is embedded into the window title pane
+	 * if window decorations are enabled.
+	 * <p>
+	 * Setting this enables/disables embedding
+	 * for the window that contains the root pane.
+	 * <p>
+	 * This client property has lower priority than system property
+	 * {@link FlatSystemProperties#MENUBAR_EMBEDDED}, but higher priority
+	 * than UI default {@code TitlePane.menuBarEmbedded}.
+	 * <p>
+	 * (requires Window 10)
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 */
+	String MENU_BAR_EMBEDDED = "JRootPane.menuBarEmbedded";
+
+	/**
+	 * Background color of window title bar (requires enabled window decorations).
+	 * <p>
+	 * (requires Window 10)
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.awt.Color}
+	 *
+	 * @since 1.1.2
+	 */
+	String TITLE_BAR_BACKGROUND = "JRootPane.titleBarBackground";
+
+	/**
+	 * Foreground color of window title bar (requires enabled window decorations).
+	 * <p>
+	 * (requires Window 10)
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JRootPane}<br>
+	 * <strong>Value type</strong> {@link java.awt.Color}
+	 *
+	 * @since 1.1.2
+	 */
+	String TITLE_BAR_FOREGROUND = "JRootPane.titleBarForeground";
+
+	//---- JScrollBar / JScrollPane -------------------------------------------
+
 	/**
 	 * Specifies whether the decrease/increase arrow buttons of a scrollbar are shown.
 	 * <p>
@@ -117,6 +314,16 @@ public interface FlatClientProperties
 	 */
 	String SCROLL_BAR_SHOW_BUTTONS = "JScrollBar.showButtons";
 
+	/**
+	 * Specifies whether the scroll pane uses smooth scrolling.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JScrollPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 */
+	String SCROLL_PANE_SMOOTH_SCROLLING = "JScrollPane.smoothScrolling";
+
+	//---- JTabbedPane --------------------------------------------------------
+
 	/**
 	 * Specifies whether separators are shown between tabs.
 	 * <p>
@@ -125,6 +332,14 @@ public interface FlatClientProperties
 	 */
 	String TABBED_PANE_SHOW_TAB_SEPARATORS = "JTabbedPane.showTabSeparators";
 
+	/**
+	 * Specifies whether the separator between tabs area and content area should be shown.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 */
+	String TABBED_PANE_SHOW_CONTENT_SEPARATOR = "JTabbedPane.showContentSeparator";
+
 	/**
 	 * Specifies whether a full border is painted around a tabbed pane.
 	 * <p>
@@ -134,21 +349,356 @@ public interface FlatClientProperties
 	String TABBED_PANE_HAS_FULL_BORDER = "JTabbedPane.hasFullBorder";
 
 	/**
-	 * Specifies the height of a tab.
+	 * Specifies whether the tab area should be hidden if it contains only one tab.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 */
+	String TABBED_PANE_HIDE_TAB_AREA_WITH_ONE_TAB = "JTabbedPane.hideTabAreaWithOneTab";
+
+	/**
+	 * Specifies the minimum width of a tab.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}
+	 * or tab content components (see {@link javax.swing.JTabbedPane#setComponentAt(int, java.awt.Component)})<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer}
+	 */
+	String TABBED_PANE_MINIMUM_TAB_WIDTH = "JTabbedPane.minimumTabWidth";
+
+	/**
+	 * Specifies the maximum width of a tab.
+	 * <p>
+	 * Applied only if tab does not have a custom tab component
+	 * (see {@link javax.swing.JTabbedPane#setTabComponentAt(int, java.awt.Component)}).
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}
+	 * or tab content components (see {@link javax.swing.JTabbedPane#setComponentAt(int, java.awt.Component)})<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer}
+	 */
+	String TABBED_PANE_MAXIMUM_TAB_WIDTH = "JTabbedPane.maximumTabWidth";
+
+	/**
+	 * Specifies the minimum height of a tab.
 	 * <p>
 	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
 	 * <strong>Value type</strong> {@link java.lang.Integer}
+	 *
+	 * @see #TABBED_PANE_TAB_INSETS
 	 */
 	String TABBED_PANE_TAB_HEIGHT = "JTabbedPane.tabHeight";
 
+	/**
+	 * Specifies the insets of a tab.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}
+	 * or tab content components (see {@link javax.swing.JTabbedPane#setComponentAt(int, java.awt.Component)})<br>
+	 * <strong>Value type</strong> {@link java.awt.Insets}
+	 *
+	 * @see #TABBED_PANE_TAB_HEIGHT
+	 */
+	String TABBED_PANE_TAB_INSETS = "JTabbedPane.tabInsets";
+
+	/**
+	 * Specifies the insets of the tab area.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
+	 * <strong>Value type</strong> {@link java.awt.Insets}
+	 */
+	String TABBED_PANE_TAB_AREA_INSETS = "JTabbedPane.tabAreaInsets";
+
+	/**
+	 * Specifies whether tabs are closable.
+	 * If set to {@code true} on a tabbed pane component, all tabs in that tabbed pane are closable.
+	 * To make individual tabs closable, set it to {@code true} on a tab content component.
+	 * <p>
+	 * Note that you have to specify a callback (see {@link #TABBED_PANE_TAB_CLOSABLE})
+	 * that is invoked when the user clicks a tab close button.
+	 * The callback is responsible for closing the tab.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}
+	 * or tab content components (see {@link javax.swing.JTabbedPane#setComponentAt(int, java.awt.Component)})<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 *
+	 * @see #TABBED_PANE_TAB_CLOSE_CALLBACK
+	 */
+	String TABBED_PANE_TAB_CLOSABLE = "JTabbedPane.tabClosable";
+
+	/**
+	 * Specifies the tooltip text used for tab close buttons.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}
+	 * or tab content components (see {@link javax.swing.JTabbedPane#setComponentAt(int, java.awt.Component)})<br>
+	 * <strong>Value type</strong> {@link java.lang.String}
+	 *
+	 * @see #TABBED_PANE_TAB_CLOSABLE
+	 */
+	String TABBED_PANE_TAB_CLOSE_TOOLTIPTEXT = "JTabbedPane.tabCloseToolTipText";
+
+	/**
+	 * Specifies the callback that is invoked when a tab close button is clicked.
+	 * The callback is responsible for closing the tab.
+	 * <p>
+	 * Either use a {@link java.util.function.IntConsumer} that receives the tab index as parameter:
+	 * <pre>{@code
+	 * myTabbedPane.putClientProperty( "JTabbedPane.tabCloseCallback",
+	 *     (IntConsumer) tabIndex -> {
+	 *         // close tab here
+	 *     } );
+	 * }</pre>
+	 * Or use a {@link java.util.function.BiConsumer}&lt;javax.swing.JTabbedPane, Integer&gt;
+	 * that receives the tabbed pane and the tab index as parameters:
+	 * <pre>{@code
+	 * myTabbedPane.putClientProperty( "JTabbedPane.tabCloseCallback",
+	 *     (BiConsumer<JTabbedPane, Integer>) (tabbedPane, tabIndex) -> {
+	 *         // close tab here
+	 *     } );
+	 * }</pre>
+	 * If you need to check whether a modifier key (e.g. Alt or Shift) was pressed
+	 * while the user clicked the tab close button, use {@link java.awt.EventQueue#getCurrentEvent}
+	 * to get current event, check whether it is a {@link java.awt.event.MouseEvent}
+	 * and invoke its methods. E.g.
+	 * <pre>{@code
+	 * AWTEvent e = EventQueue.getCurrentEvent();
+	 * boolean shift = (e instanceof MouseEvent) ? ((MouseEvent)e).isShiftDown() : false;
+	 * }</pre>
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}
+	 * or tab content components (see {@link javax.swing.JTabbedPane#setComponentAt(int, java.awt.Component)})<br>
+	 * <strong>Value type</strong> {@link java.util.function.IntConsumer}
+	 * or {@link java.util.function.BiConsumer}&lt;javax.swing.JTabbedPane, Integer&gt;
+	 *
+	 * @see #TABBED_PANE_TAB_CLOSABLE
+	 */
+	String TABBED_PANE_TAB_CLOSE_CALLBACK = "JTabbedPane.tabCloseCallback";
+
+	/**
+	 * Specifies the display policy for the "more tabs" button,
+	 * which shows a popup menu with the (partly) hidden tabs.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.String}<br>
+	 * <strong>Allowed Values</strong>
+	 *     {@link #TABBED_PANE_POLICY_NEVER} or
+	 *     {@link #TABBED_PANE_POLICY_AS_NEEDED}
+	 */
+	String TABBED_PANE_TABS_POPUP_POLICY = "JTabbedPane.tabsPopupPolicy";
+
+	/**
+	 * Specifies the display policy for the forward/backward scroll arrow buttons.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.String}<br>
+	 * <strong>Allowed Values</strong>
+	 *     {@link #TABBED_PANE_POLICY_NEVER},
+	 *     {@link #TABBED_PANE_POLICY_AS_NEEDED} or
+	 *     {@link #TABBED_PANE_POLICY_AS_NEEDED_SINGLE}
+	 */
+	String TABBED_PANE_SCROLL_BUTTONS_POLICY = "JTabbedPane.scrollButtonsPolicy";
+
+	/**
+	 * Display never.
+	 *
+	 * @see #TABBED_PANE_TABS_POPUP_POLICY
+	 * @see #TABBED_PANE_SCROLL_BUTTONS_POLICY
+	 */
+	String TABBED_PANE_POLICY_NEVER = "never";
+
+	/**
+	 * Display only when needed.
+	 * <p>
+	 * If used for {@link #TABBED_PANE_SCROLL_BUTTONS_POLICY}, both scroll arrow buttons
+	 * are either shown or hidden. Buttons are disabled if scrolling in that
+	 * direction is not applicable.
+	 *
+	 * @see #TABBED_PANE_TABS_POPUP_POLICY
+	 * @see #TABBED_PANE_SCROLL_BUTTONS_POLICY
+	 */
+	String TABBED_PANE_POLICY_AS_NEEDED = "asNeeded";
+
+	/**
+	 * Display single button only when needed.
+	 * <p>
+	 * If scroll button placement is trailing, then this option is ignored
+	 * and both buttons are shown or hidden as needed.
+	 *
+	 * @see #TABBED_PANE_SCROLL_BUTTONS_POLICY
+	 */
+	String TABBED_PANE_POLICY_AS_NEEDED_SINGLE = "asNeededSingle";
+
+	/**
+	 * Specifies the placement of the forward/backward scroll arrow buttons.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.String}<br>
+	 * <strong>Allowed Values</strong>
+	 *     {@link #TABBED_PANE_PLACEMENT_BOTH} or
+	 *     {@link #TABBED_PANE_PLACEMENT_TRAILING}
+	 */
+	String TABBED_PANE_SCROLL_BUTTONS_PLACEMENT = "JTabbedPane.scrollButtonsPlacement";
+
+	/**
+	 * The forward/backward scroll arrow buttons are placed on both sides of the tab area.
+	 * The backward scroll button at the left/top side.
+	 * The forward scroll button at the right/bottom side.
+	 *
+	 * @see #TABBED_PANE_SCROLL_BUTTONS_PLACEMENT
+	 */
+	String TABBED_PANE_PLACEMENT_BOTH = "both";
+
+	/**
+	 * The forward/backward scroll arrow buttons are placed on the trailing side of the tab area.
+	 *
+	 * @see #TABBED_PANE_SCROLL_BUTTONS_PLACEMENT
+	 */
+	String TABBED_PANE_PLACEMENT_TRAILING = "trailing";
+
+	/**
+	 * Specifies the alignment of the tab area.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer} or {@link java.lang.String}<br>
+	 * <strong>Allowed Values</strong>
+	 *     {@link SwingConstants#LEADING} (default)
+	 *     {@link SwingConstants#TRAILING},
+	 *     {@link SwingConstants#CENTER},
+	 *     {@link #TABBED_PANE_ALIGN_LEADING} (default),
+	 *     {@link #TABBED_PANE_ALIGN_TRAILING},
+	 *     {@link #TABBED_PANE_ALIGN_CENTER} or
+	 *     {@link #TABBED_PANE_ALIGN_FILL}
+	 */
+	String TABBED_PANE_TAB_AREA_ALIGNMENT = "JTabbedPane.tabAreaAlignment";
+
+	/**
+	 * Specifies the horizontal alignment of the tab title and icon.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}
+	 * or tab content components (see {@link javax.swing.JTabbedPane#setComponentAt(int, java.awt.Component)})<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer} or {@link java.lang.String}<br>
+	 * <strong>Allowed Values</strong>
+	 *     {@link SwingConstants#LEADING},
+	 *     {@link SwingConstants#TRAILING},
+	 *     {@link SwingConstants#CENTER} (default),
+	 *     {@link #TABBED_PANE_ALIGN_LEADING},
+	 *     {@link #TABBED_PANE_ALIGN_TRAILING} or
+	 *     {@link #TABBED_PANE_ALIGN_CENTER} (default)
+	 */
+	String TABBED_PANE_TAB_ALIGNMENT = "JTabbedPane.tabAlignment";
+
+	/**
+	 * Align to the leading edge.
+	 *
+	 * @see #TABBED_PANE_TAB_AREA_ALIGNMENT
+	 * @see #TABBED_PANE_TAB_ALIGNMENT
+	 */
+	String TABBED_PANE_ALIGN_LEADING = "leading";
+
+	/**
+	 * Align to the trailing edge.
+	 *
+	 * @see #TABBED_PANE_TAB_AREA_ALIGNMENT
+	 * @see #TABBED_PANE_TAB_ALIGNMENT
+	 */
+	String TABBED_PANE_ALIGN_TRAILING = "trailing";
+
+	/**
+	 * Align to center.
+	 *
+	 * @see #TABBED_PANE_TAB_AREA_ALIGNMENT
+	 * @see #TABBED_PANE_TAB_ALIGNMENT
+	 */
+	String TABBED_PANE_ALIGN_CENTER = "center";
+
+	/**
+	 * Stretch to fill all available space.
+	 *
+	 * @see #TABBED_PANE_TAB_AREA_ALIGNMENT
+	 */
+	String TABBED_PANE_ALIGN_FILL = "fill";
+
+	/**
+	 * Specifies how the tabs should be sized.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.String}<br>
+	 * <strong>Allowed Values</strong>
+	 *     {@link #TABBED_PANE_TAB_WIDTH_MODE_PREFERRED} (default),
+	 *     {@link #TABBED_PANE_TAB_WIDTH_MODE_EQUAL} or
+	 *     {@link #TABBED_PANE_TAB_WIDTH_MODE_COMPACT}
+	 */
+	String TABBED_PANE_TAB_WIDTH_MODE = "JTabbedPane.tabWidthMode";
+
+	/**
+	 * Tab width is adjusted to tab icon and title.
+	 *
+	 * @see #TABBED_PANE_TAB_WIDTH_MODE
+	 */
+	String TABBED_PANE_TAB_WIDTH_MODE_PREFERRED = "preferred";
+
+	/**
+	 * All tabs in a tabbed pane has same width.
+	 *
+	 * @see #TABBED_PANE_TAB_WIDTH_MODE
+	 */
+	String TABBED_PANE_TAB_WIDTH_MODE_EQUAL = "equal";
+
+	/**
+	 * Unselected tabs are smaller because they show only the tab icon, but no tab title.
+	 * Selected tabs show both.
+	 *
+	 * @see #TABBED_PANE_TAB_WIDTH_MODE
+	 */
+	String TABBED_PANE_TAB_WIDTH_MODE_COMPACT = "compact";
+
+	/**
+	 * Specifies the tab icon placement (relative to tab title).
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
+	 * <strong>Value type</strong> {@link java.lang.Integer}<br>
+	 * <strong>Allowed Values</strong>
+	 *     {@link SwingConstants#LEADING} (default),
+	 *     {@link SwingConstants#TRAILING},
+	 *     {@link SwingConstants#TOP} or
+	 *     {@link SwingConstants#BOTTOM}
+	 */
+	String TABBED_PANE_TAB_ICON_PLACEMENT = "JTabbedPane.tabIconPlacement";
+
+	/**
+	 * Specifies a component that will be placed at the leading edge of the tabs area.
+	 * <p>
+	 * For top and bottom tab placement, the layed out component size will be
+	 * the preferred component width and the tab area height.<br>
+	 * For left and right tab placement, the layed out component size will be
+	 * the tab area width and the preferred component height.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
+	 * <strong>Value type</strong> {@link java.awt.Component}
+	 */
+	String TABBED_PANE_LEADING_COMPONENT = "JTabbedPane.leadingComponent";
+
+	/**
+	 * Specifies a component that will be placed at the trailing edge of the tabs area.
+	 * <p>
+	 * For top and bottom tab placement, the layed out component size will be
+	 * the available horizontal space (minimum is preferred component width) and the tab area height.<br>
+	 * For left and right tab placement, the layed out component size will be
+	 * the tab area width and the available vertical space (minimum is preferred component height).
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTabbedPane}<br>
+	 * <strong>Value type</strong> {@link java.awt.Component}
+	 */
+	String TABBED_PANE_TRAILING_COMPONENT = "JTabbedPane.trailingComponent";
+
+	//---- JTextField ---------------------------------------------------------
+
 	/**
 	 * Specifies whether all text is selected when the text component gains focus.
 	 * <p>
 	 * <strong>Component</strong> {@link javax.swing.JTextField} (and subclasses)<br>
 	 * <strong>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}
+	 * <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";
 
@@ -183,6 +733,20 @@ public interface FlatClientProperties
 	 */
 	String PLACEHOLDER_TEXT = "JTextField.placeholderText";
 
+	/**
+	 * Specifies the padding of the text.
+	 * This changes the location and size of the text view within the component bounds,
+	 * but does not affect the size of the component.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTextField} (and subclasses)<br>
+	 * <strong>Value type</strong> {@link java.awt.Insets}
+	 *
+	 * @since 1.4
+	 */
+	String TEXT_FIELD_PADDING = "JTextField.padding";
+
+	//---- JToggleButton ------------------------------------------------------
+
 	/**
 	 * Height of underline if toggle button type is {@link #BUTTON_TYPE_TAB}.
 	 * <p>
@@ -207,6 +771,27 @@ public interface FlatClientProperties
 	 */
 	String TAB_BUTTON_SELECTED_BACKGROUND = "JToggleButton.tab.selectedBackground";
 
+	//---- JTree --------------------------------------------------------------
+
+	/**
+	 * Override if a tree shows a wide selection. Default is {@code true}.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTree}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 */
+	String TREE_WIDE_SELECTION = "JTree.wideSelection";
+
+	/**
+	 * Specifies whether tree item selection is painted. Default is {@code true}.
+	 * If set to {@code false}, then the tree cell renderer is responsible for painting selection.
+	 * <p>
+	 * <strong>Component</strong> {@link javax.swing.JTree}<br>
+	 * <strong>Value type</strong> {@link java.lang.Boolean}
+	 */
+	String TREE_PAINT_SELECTION = "JTree.paintSelection";
+
+	//---- helper methods -----------------------------------------------------
+
 	/**
 	 * Checks whether a client property of a component has the given value.
 	 */
@@ -223,6 +808,15 @@ public interface FlatClientProperties
 		return (value instanceof Boolean) ? (boolean) value : defaultValue;
 	}
 
+	/**
+	 * Checks whether a client property of a component is a {@link Boolean} and returns its value.
+	 * If the client property is not set, or not a {@link Boolean}, defaultValue is returned.
+	 */
+	static Boolean clientPropertyBooleanStrict( JComponent c, String key, Boolean defaultValue ) {
+		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.

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

@@ -16,27 +16,54 @@
 
 package com.formdev.flatlaf;
 
+import javax.swing.UIManager;
+
 /**
  * A Flat LaF that has a dark color scheme and looks like Darcula LaF.
- *
- * The UI defaults are loaded from FlatDarculaLaf.properties, FlatDarkLaf.properties and FlatLaf.properties
+ * <p>
+ * The UI defaults are loaded from {@code FlatDarculaLaf.properties},
+ * {@code FlatDarkLaf.properties} and {@code FlatLaf.properties}.
  *
  * @author Karl Tauber
  */
 public class FlatDarculaLaf
 	extends FlatDarkLaf
 {
-	public static boolean install( ) {
-		return install( new FlatDarculaLaf() );
+	public static final String NAME = "FlatLaf Darcula";
+
+	/**
+	 * Sets the application look and feel to this LaF
+	 * using {@link UIManager#setLookAndFeel(javax.swing.LookAndFeel)}.
+	 */
+	public static boolean setup() {
+		return setup( new FlatDarculaLaf() );
+	}
+
+	/**
+	 * @deprecated use {@link #setup()} instead; this method will be removed in a future version
+	 */
+	@Deprecated
+	public static boolean install() {
+		return setup();
+	}
+
+	/**
+	 * Adds this look and feel to the set of available look and feels.
+	 * <p>
+	 * Useful if your application uses {@link UIManager#getInstalledLookAndFeels()}
+	 * to query available LaFs and display them to the user in a combobox.
+	 */
+	public static void installLafInfo() {
+		installLafInfo( NAME, FlatDarculaLaf.class );
 	}
 
 	@Override
 	public String getName() {
-		return "Flat Darcula";
+		return NAME;
 	}
 
 	@Override
 	public String getDescription() {
-		return "Flat Darcula Look and Feel";
+		return "FlatLaf Darcula Look and Feel";
 	}
 }

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

@@ -16,28 +16,54 @@
 
 package com.formdev.flatlaf;
 
+import javax.swing.UIManager;
+
 /**
  * A Flat LaF that has a dark color scheme.
- *
- * The UI defaults are loaded from FlatDarkLaf.properties and FlatLaf.properties
+ * <p>
+ * The UI defaults are loaded from {@code FlatDarkLaf.properties} and {@code FlatLaf.properties}.
  *
  * @author Karl Tauber
  */
 public class FlatDarkLaf
 	extends FlatLaf
 {
-	public static boolean install( ) {
-		return install( new FlatDarkLaf() );
+	public static final String NAME = "FlatLaf Dark";
+
+	/**
+	 * Sets the application look and feel to this LaF
+	 * using {@link UIManager#setLookAndFeel(javax.swing.LookAndFeel)}.
+	 */
+	public static boolean setup() {
+		return setup( new FlatDarkLaf() );
+	}
+
+	/**
+	 * @deprecated use {@link #setup()} instead; this method will be removed in a future version
+	 */
+	@Deprecated
+	public static boolean install() {
+		return setup();
+	}
+
+	/**
+	 * Adds this look and feel to the set of available look and feels.
+	 * <p>
+	 * Useful if your application uses {@link UIManager#getInstalledLookAndFeels()}
+	 * to query available LaFs and display them to the user in a combobox.
+	 */
+	public static void installLafInfo() {
+		installLafInfo( NAME, FlatDarkLaf.class );
 	}
 
 	@Override
 	public String getName() {
-		return "Flat Dark";
+		return NAME;
 	}
 
 	@Override
 	public String getDescription() {
-		return "Flat Dark Look and Feel";
+		return "FlatLaf Dark Look and Feel";
 	}
 
 	@Override

flatlaf-core/src/main/java/com/formdev/flatlaf/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

@@ -22,9 +22,11 @@ import javax.swing.KeyStroke;
 import javax.swing.LookAndFeel;
 import javax.swing.UIDefaults;
 import javax.swing.UIDefaults.LazyValue;
+import javax.swing.UIManager;
 import javax.swing.plaf.InputMapUIResource;
 import com.formdev.flatlaf.util.SystemInfo;
 import static javax.swing.text.DefaultEditorKit.*;
+import java.util.function.BooleanSupplier;
 
 /**
  * @author Karl Tauber
@@ -35,15 +37,17 @@ class FlatInputMaps
 		initBasicInputMaps( defaults );
 		initTextComponentInputMaps( defaults );
 
-		if( SystemInfo.IS_MAC )
+		if( SystemInfo.isMacOS )
 			initMacInputMaps( defaults );
 	}
 
 	private static void initBasicInputMaps( UIDefaults defaults ) {
-		defaults.put( "Button.focusInputMap", new UIDefaults.LazyInputMap( new Object[] {
-			"SPACE", "pressed",
-			"released SPACE", "released"
-		} ) );
+		if( SystemInfo.isMacOS ) {
+			defaults.put( "Button.focusInputMap", new UIDefaults.LazyInputMap( new Object[] {
+				"SPACE", "pressed",
+				"released SPACE", "released"
+			} ) );
+		}
 
 		modifyInputMap( defaults, "ComboBox.ancestorInputMap",
 			"SPACE", "spacePopup",
@@ -59,7 +63,7 @@ class FlatInputMaps
 			mac( "alt KP_DOWN", null ), "togglePopup"
 		);
 
-		if( !SystemInfo.IS_MAC ) {
+		if( !SystemInfo.isMacOS ) {
 			modifyInputMap( defaults, "FileChooser.ancestorInputMap",
 				"F2", "editFileName",
 				"BACK_SPACE", "Go Up"
@@ -81,15 +85,22 @@ class FlatInputMaps
 			"shift ctrl TAB", "navigatePrevious"
 		);
 
-		modifyInputMap( defaults, "Table.ancestorInputMap",
-			// swap to make it consistent with List and Tree
+		// swap Home/End with Ctrl+Home/End to make it consistent with List and Tree
+		modifyInputMap( () -> {
+				return UIManager.getBoolean( "Table.consistentHomeEndKeyBehavior" );
+			},
+			defaults, "Table.ancestorInputMap",
 			"HOME", "selectFirstRow",
 			"END", "selectLastRow",
+			"shift HOME", "selectFirstRowExtendSelection",
+			"shift END", "selectLastRowExtendSelection",
 			mac( "ctrl HOME", null ), "selectFirstColumn",
-			mac( "ctrl END", null ), "selectLastColumn"
+			mac( "ctrl END", null ), "selectLastColumn",
+			mac( "shift ctrl HOME", null ), "selectFirstColumnExtendSelection",
+			mac( "shift ctrl END", null ), "selectLastColumnExtendSelection"
 		);
 
-		if( !SystemInfo.IS_MAC ) {
+		if( !SystemInfo.isMacOS ) {
 			modifyInputMap( defaults, "Tree.focusInputMap",
 				"ADD", "expand",
 				"SUBTRACT", "collapse"
@@ -160,7 +171,7 @@ class FlatInputMaps
 			"control shift O", "toggle-componentOrientation", // DefaultEditorKit.toggleComponentOrientation
 		};
 
-		Object[] macCommonTextComponentBindings = SystemInfo.IS_MAC ? new Object[] {
+		Object[] macCommonTextComponentBindings = SystemInfo.isMacOS ? new Object[] {
 			// move caret one character (without selecting text)
 			"ctrl B", backwardAction,
 			"ctrl F", forwardAction,
@@ -207,7 +218,7 @@ class FlatInputMaps
 			"ENTER", JTextField.notifyAction,
 		};
 
-		Object[] macSingleLineTextComponentBindings = SystemInfo.IS_MAC ? new Object[] {
+		Object[] macSingleLineTextComponentBindings = SystemInfo.isMacOS ? new Object[] {
 			// move caret to line begin/end (without selecting text)
 			"UP", beginLineAction,
 			"DOWN", endLineAction,
@@ -285,7 +296,7 @@ class FlatInputMaps
 			mac( "ctrl SPACE", "meta SPACE" ), "activate-link-action",
 		};
 
-		Object[] macMultiLineTextComponentBindings = SystemInfo.IS_MAC ? new Object[] {
+		Object[] macMultiLineTextComponentBindings = SystemInfo.isMacOS ? new Object[] {
 			// move caret one line (without selecting text)
 			"ctrl N", downAction,
 			"ctrl P", upAction,
@@ -501,6 +512,9 @@ class FlatInputMaps
 			"alt KP_LEFT", "selectParent",
 			"alt KP_RIGHT", "selectChild",
 
+			"shift HOME", "selectFirstExtendSelection",
+			"shift END", "selectLastExtendSelection",
+
 		    "meta A", "selectAll",
 		    "meta C", "copy",
 		    "meta V", "paste",
@@ -545,8 +559,6 @@ class FlatInputMaps
 			"shift ctrl SPACE", null,
 			"shift ctrl UP", null,
 			"shift DELETE", null,
-			"shift END", null,
-			"shift HOME", null,
 			"shift INSERT", null,
 			"shift PAGE_DOWN", null,
 			"shift PAGE_UP", null,
@@ -569,12 +581,16 @@ class FlatInputMaps
 	}
 
 	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 ) );
+		modifyInputMap( null, defaults, key, bindings );
+	}
+
+	private static void modifyInputMap( BooleanSupplier condition, UIDefaults defaults, String key, Object... bindings ) {
+		// Note: not using `defaults.get(key)` here because this would resolve a lazy value
+		defaults.put( key, new LazyModifyInputMap( condition, defaults.remove( key ), bindings ) );
 	}
 
 	private static <T> T mac( T value, T macValue ) {
-		return SystemInfo.IS_MAC ? macValue : value;
+		return SystemInfo.isMacOS ? macValue : value;
 	}
 
 	//---- class LazyInputMapEx -----------------------------------------------
@@ -609,10 +625,12 @@ class FlatInputMaps
 	private static class LazyModifyInputMap
 		implements LazyValue
 	{
+		private final BooleanSupplier condition;
 		private final Object baseInputMap;
 		private final Object[] bindings;
 
-		LazyModifyInputMap( Object baseInputMap, Object[] bindings ) {
+		LazyModifyInputMap( BooleanSupplier condition, Object baseInputMap, Object[] bindings ) {
+			this.condition = condition;
 			this.baseInputMap = baseInputMap;
 			this.bindings = bindings;
 		}
@@ -624,6 +642,9 @@ class FlatInputMaps
 				? (InputMap) ((LazyValue)baseInputMap).createValue( table )
 				: (InputMap) baseInputMap;
 
+			if( condition != null && !condition.getAsBoolean() )
+				return inputMap;
+
 			// modify input map (replace or remove)
 			for( int i = 0; i < bindings.length; i += 2 ) {
 				KeyStroke keyStroke = KeyStroke.getKeyStroke( (String) bindings[i] );

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

@@ -16,27 +16,54 @@
 
 package com.formdev.flatlaf;
 
+import javax.swing.UIManager;
+
 /**
  * A Flat LaF that has a light color scheme and looks like IntelliJ LaF.
- *
- * The UI defaults are loaded from FlatIntelliJLaf.properties, FlatLightLaf.properties and FlatLaf.properties
+ * <p>
+ * The UI defaults are loaded from {@code FlatIntelliJLaf.properties},
+ * {@code FlatLightLaf.properties} and {@code FlatLaf.properties}.
  *
  * @author Karl Tauber
  */
 public class FlatIntelliJLaf
 	extends FlatLightLaf
 {
-	public static boolean install( ) {
-		return install( new FlatIntelliJLaf() );
+	public static final String NAME = "FlatLaf IntelliJ";
+
+	/**
+	 * Sets the application look and feel to this LaF
+	 * using {@link UIManager#setLookAndFeel(javax.swing.LookAndFeel)}.
+	 */
+	public static boolean setup() {
+		return setup( new FlatIntelliJLaf() );
+	}
+
+	/**
+	 * @deprecated use {@link #setup()} instead; this method will be removed in a future version
+	 */
+	@Deprecated
+	public static boolean install() {
+		return setup();
+	}
+
+	/**
+	 * Adds this look and feel to the set of available look and feels.
+	 * <p>
+	 * Useful if your application uses {@link UIManager#getInstalledLookAndFeels()}
+	 * to query available LaFs and display them to the user in a combobox.
+	 */
+	public static void installLafInfo() {
+		installLafInfo( NAME, FlatIntelliJLaf.class );
 	}
 
 	@Override
 	public String getName() {
-		return "Flat IntelliJ";
+		return NAME;
 	}
 
 	@Override
 	public String getDescription() {
-		return "Flat IntelliJ Look and Feel";
+		return "FlatLaf IntelliJ Look and Feel";
 	}
 }

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

@@ -16,28 +16,54 @@
 
 package com.formdev.flatlaf;
 
+import javax.swing.UIManager;
+
 /**
  * A Flat LaF that has a light color scheme.
- *
- * The UI defaults are loaded from FlatLightLaf.properties and FlatLaf.properties
+ * <p>
+ * The UI defaults are loaded from {@code FlatLightLaf.properties} and {@code FlatLaf.properties}.
  *
  * @author Karl Tauber
  */
 public class FlatLightLaf
 	extends FlatLaf
 {
-	public static boolean install( ) {
-		return install( new FlatLightLaf() );
+	public static final String NAME = "FlatLaf Light";
+
+	/**
+	 * Sets the application look and feel to this LaF
+	 * using {@link UIManager#setLookAndFeel(javax.swing.LookAndFeel)}.
+	 */
+	public static boolean setup() {
+		return setup( new FlatLightLaf() );
+	}
+
+	/**
+	 * @deprecated use {@link #setup()} instead; this method will be removed in a future version
+	 */
+	@Deprecated
+	public static boolean install() {
+		return setup();
+	}
+
+	/**
+	 * Adds this look and feel to the set of available look and feels.
+	 * <p>
+	 * Useful if your application uses {@link UIManager#getInstalledLookAndFeels()}
+	 * to query available LaFs and display them to the user in a combobox.
+	 */
+	public static void installLafInfo() {
+		installLafInfo( NAME, FlatLightLaf.class );
 	}
 
 	@Override
 	public String getName() {
-		return "Flat Light";
+		return NAME;
 	}
 
 	@Override
 	public String getDescription() {
-		return "Flat Light Look and Feel";
+		return "FlatLaf Light Look and Feel";
 	}
 
 	@Override

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

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Properties;
+
+/**
+ * A Flat LaF that is able to load UI defaults from properties passed to the constructor.
+ * <p>
+ * Specify the base theme in the properties with {@code @baseTheme=<baseTheme>}.
+ * Allowed values for {@code <baseTheme>} are {@code light} (the default), {@code dark},
+ * {@code intellij} or {@code darcula}.
+ * <p>
+ * The properties are applied after loading the base theme and may overwrite base properties.
+ * All features of FlatLaf properties files are available.
+ *
+ * @author Karl Tauber
+ */
+public class FlatPropertiesLaf
+	extends FlatLaf
+{
+	private final String name;
+	private final String baseTheme;
+	private final boolean dark;
+	private final Properties properties;
+
+	public FlatPropertiesLaf( String name, File propertiesFile )
+		throws IOException
+	{
+		this( name, new FileInputStream( propertiesFile ) );
+	}
+
+	public FlatPropertiesLaf( String name, InputStream in )
+		throws IOException
+	{
+		this( name, loadProperties( in ) );
+	}
+
+	private static Properties loadProperties( InputStream in )
+		throws IOException
+	{
+		Properties properties = new Properties();
+		try( InputStream in2 = in ) {
+			properties.load( in2 );
+		}
+		return properties;
+	}
+
+	public FlatPropertiesLaf( String name, Properties properties ) {
+		this.name = name;
+		this.properties = properties;
+
+		baseTheme = properties.getProperty( "@baseTheme", "light" );
+		dark = "dark".equalsIgnoreCase( baseTheme ) || "darcula".equalsIgnoreCase( baseTheme );
+	}
+
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public String getDescription() {
+		return name;
+	}
+
+	@Override
+	public boolean isDark() {
+		return dark;
+	}
+
+	public Properties getProperties() {
+		return properties;
+	}
+
+	@Override
+	protected ArrayList<Class<?>> getLafClassesForDefaultsLoading() {
+		ArrayList<Class<?>> lafClasses = new ArrayList<>();
+		lafClasses.add( FlatLaf.class );
+		switch( baseTheme.toLowerCase() ) {
+			default:
+			case "light":
+				lafClasses.add( FlatLightLaf.class );
+				break;
+
+			case "dark":
+				lafClasses.add( FlatDarkLaf.class );
+				break;
+
+			case "intellij":
+				lafClasses.add( FlatLightLaf.class );
+				lafClasses.add( FlatIntelliJLaf.class );
+				break;
+
+			case "darcula":
+				lafClasses.add( FlatDarkLaf.class );
+				lafClasses.add( FlatDarculaLaf.class );
+				break;
+		}
+		return lafClasses;
+	}
+
+	@Override
+	protected Properties getAdditionalDefaults() {
+		return properties;
+	}
+}

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

@@ -0,0 +1,165 @@
+/*
+ * 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 com.formdev.flatlaf.util.UIScale;
+
+/**
+ * Defines/documents own system properties used in FlatLaf.
+ *
+ * @author Karl Tauber
+ */
+public interface FlatSystemProperties
+{
+	/**
+	 * Specifies a custom scale factor used to scale the UI.
+	 * <p>
+	 * If Java runtime scales (Java 9 or later), this scale factor is applied on top
+	 * of the Java system scale factor. Java 8 does not scale and this scale factor
+	 * replaces the user scale factor that FlatLaf computes based on the font.
+	 * To replace the Java 9+ system scale factor, use system property "sun.java2d.uiScale",
+	 * which has the same syntax as this one.
+	 * <p>
+	 * Since FlatLaf 1.1.2: Scale factors less then 100% are allowed.
+	 * <p>
+	 * <strong>Allowed Values</strong> e.g. {@code 1.5}, {@code 1.5x}, {@code 150%} or {@code 144dpi} (96dpi is 100%)<br>
+	 */
+	String UI_SCALE = "flatlaf.uiScale";
+
+	/**
+	 * Specifies whether user scaling mode is enabled.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}
+	 */
+	String UI_SCALE_ENABLED = "flatlaf.uiScale.enabled";
+
+	/**
+	 * Specifies whether values smaller than 100% are allowed for the user scale factor
+	 * (see {@link UIScale#getUserScaleFactor()}).
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code false}
+	 *
+	 * @since 1.1.2
+	 */
+	String UI_SCALE_ALLOW_SCALE_DOWN = "flatlaf.uiScale.allowScaleDown";
+
+	/**
+	 * Specifies whether Ubuntu font should be used on Ubuntu Linux.
+	 * By default, if not running in a JetBrains Runtime, the Liberation Sans font
+	 * is used because there are rendering issues (in Java) with Ubuntu fonts.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code false}
+	 */
+	String USE_UBUNTU_FONT = "flatlaf.useUbuntuFont";
+
+	/**
+	 * Specifies whether native window decorations should be used
+	 * when creating {@code JFrame} or {@code JDialog}.
+	 * <p>
+	 * Setting this to {@code true} forces using native window decorations
+	 * even if they are not enabled by the application.<br>
+	 * Setting this to {@code false} disables using native window decorations.
+	 * <p>
+	 * This system property has higher priority than client property
+	 * {@link FlatClientProperties#USE_WINDOW_DECORATIONS} and
+	 * UI default {@code TitlePane.useWindowDecorations}.
+	 * <p>
+	 * (requires Window 10)
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> none
+	 */
+	String USE_WINDOW_DECORATIONS = "flatlaf.useWindowDecorations";
+
+	/**
+	 * Specifies whether JetBrains Runtime custom window decorations should be used
+	 * when creating {@code JFrame} or {@code JDialog}.
+	 * Requires that the application runs in a
+	 * <a href="https://confluence.jetbrains.com/display/JBR/JetBrains+Runtime">JetBrains Runtime</a>
+	 * (based on OpenJDK).
+	 * <p>
+	 * Setting this to {@code false} disables using JetBrains Runtime custom window decorations.
+	 * Then FlatLaf native window decorations are used.
+	 * <p>
+	 * (requires Window 10)
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}
+	 */
+	String USE_JETBRAINS_CUSTOM_DECORATIONS = "flatlaf.useJetBrainsCustomDecorations";
+
+	/**
+	 * Specifies whether the menu bar is embedded into the window title pane
+	 * if window decorations are enabled.
+	 * <p>
+	 * Setting this to {@code true} forces embedding.<br>
+	 * Setting this to {@code false} disables embedding.
+	 * <p>
+	 * This system property has higher priority than client property
+	 * {@link FlatClientProperties#MENU_BAR_EMBEDDED} and
+	 * UI default {@code TitlePane.menuBarEmbedded}.
+	 * <p>
+	 * (requires Window 10)
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> none
+	 */
+	String MENUBAR_EMBEDDED = "flatlaf.menuBarEmbedded";
+
+	/**
+	 * Specifies whether animations are enabled.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}
+	 */
+	String ANIMATION = "flatlaf.animation";
+
+	/**
+	 * Specifies whether vertical text position is corrected when UI is scaled on HiDPI screens.
+	 * <p>
+	 * <strong>Allowed Values</strong> {@code false} and {@code true}<br>
+	 * <strong>Default</strong> {@code true}
+	 */
+	String USE_TEXT_Y_CORRECTION = "flatlaf.useTextYCorrection";
+
+	/**
+	 * Checks whether a system property is set and returns {@code true} if its value
+	 * is {@code "true"} (case-insensitive), otherwise it returns {@code false}.
+	 * If the system property is not set, {@code defaultValue} is returned.
+	 */
+	static boolean getBoolean( String key, boolean defaultValue ) {
+		String value = System.getProperty( key );
+		return (value != null) ? Boolean.parseBoolean( value ) : defaultValue;
+	}
+
+	/**
+	 * Checks whether a system property is set and returns {@code Boolean.TRUE} if its value
+	 * is {@code "true"} (case-insensitive) or returns {@code Boolean.FALSE} if its value
+	 * is {@code "false"} (case-insensitive). Otherwise {@code defaultValue} is returned.
+	 */
+	static Boolean getBooleanStrict( String key, Boolean defaultValue ) {
+		String value = System.getProperty( key );
+		if( "true".equalsIgnoreCase( value ) )
+			return Boolean.TRUE;
+		if( "false".equalsIgnoreCase( value ) )
+			return Boolean.FALSE;
+		return defaultValue;
+	}
+}

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

@@ -16,6 +16,7 @@
 
 package com.formdev.flatlaf;
 
+import java.awt.Color;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
@@ -29,11 +30,12 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.logging.Level;
 import javax.swing.UIDefaults;
 import javax.swing.plaf.ColorUIResource;
 import com.formdev.flatlaf.json.Json;
 import com.formdev.flatlaf.json.ParseException;
+import com.formdev.flatlaf.util.ColorFunctions;
+import com.formdev.flatlaf.util.LoggingFacade;
 import com.formdev.flatlaf.util.StringUtils;
 
 /**
@@ -56,6 +58,8 @@ public class IntelliJTheme
 	public final boolean dark;
 	public final String author;
 
+	private final boolean isMaterialUILite;
+
 	private final Map<String, String> colors;
 	private final Map<String, Object> ui;
 	private final Map<String, Object> icons;
@@ -64,20 +68,28 @@ public class IntelliJTheme
 
 	/**
 	 * Loads a IntelliJ .theme.json file from the given input stream,
-	 * creates a Laf instance for it and installs it.
+	 * creates a Laf instance for it and sets it up.
 	 *
 	 * The input stream is automatically closed.
 	 * Using a buffered input stream is not necessary.
 	 */
-	public static boolean install( InputStream in ) {
+	public static boolean setup( InputStream in ) {
 		try {
-		    return FlatLaf.install( createLaf( in ) );
+		    return FlatLaf.setup( createLaf( in ) );
 		} catch( Exception ex ) {
-			FlatLaf.LOG.log( Level.SEVERE, "FlatLaf: Failed to load IntelliJ theme", ex );
+			LoggingFacade.INSTANCE.logSevere(  "FlatLaf: Failed to load IntelliJ theme", ex );
 		    return false;
 		}
 	}
 
+	/**
+	 * @deprecated use {@link #setup(InputStream)} instead; this method will be removed in a future version
+	 */
+	@Deprecated
+	public static boolean install( InputStream in ) {
+		return setup( in );
+	}
+
 	/**
 	 * Loads a IntelliJ .theme.json file from the given input stream and
 	 * creates a Laf instance for it.
@@ -86,7 +98,7 @@ public class IntelliJTheme
 	 * Using a buffered input stream is not necessary.
 	 */
 	public static FlatLaf createLaf( InputStream in )
-		throws IOException, ParseException
+		throws IOException
 	{
 		return createLaf( new IntelliJTheme( in ) );
 	}
@@ -106,17 +118,21 @@ public class IntelliJTheme
 	 */
 	@SuppressWarnings( "unchecked" )
 	public IntelliJTheme( InputStream in )
-		throws IOException, ParseException
+		throws IOException
 	{
 		Map<String, Object> json;
 	    try( Reader reader = new InputStreamReader( in, StandardCharsets.UTF_8 ) ) {
 	    		json = (Map<String, Object>) Json.parse( reader );
+		} catch( ParseException ex ) {
+			throw new IOException( ex.getMessage(), ex );
 		}
 
 	    name = (String) json.get( "name" );
 	    dark = Boolean.parseBoolean( (String) json.get( "dark" ) );
 	    author = (String) json.get( "author" );
 
+		isMaterialUILite = author.equals( "Mallowigi" );
+
 	    colors = (Map<String, String>) json.get( "colors" );
 	    ui = (Map<String, Object>) json.get( "ui" );
 	    icons = (Map<String, Object>) json.get( "icons" );
@@ -132,6 +148,8 @@ public class IntelliJTheme
 		defaults.put( "Button.paintShadow", true );
 		defaults.put( "Button.shadowWidth", dark ? 2 : 1 );
 
+		Map<Object, Object> themeSpecificDefaults = removeThemeSpecificDefaults( defaults );
+
 		loadNamedColors( defaults );
 
 		// convert Json "ui" structure to UI defaults
@@ -143,6 +161,20 @@ public class IntelliJTheme
 		applyColorPalette( defaults );
 		applyCheckBoxColors( defaults );
 
+		// copy values
+		for( Map.Entry<String, String> e : uiKeyCopying.entrySet() )
+			defaults.put( e.getKey(), defaults.get( e.getValue() ) );
+
+		// IDEA does not paint button background if disabled, but FlatLaf does
+		Object panelBackground = defaults.get( "Panel.background" );
+		defaults.put( "Button.disabledBackground", panelBackground );
+		defaults.put( "ToggleButton.disabledBackground", panelBackground );
+
+		// fix Button borders
+		copyIfNotSet( defaults, "Button.focusedBorderColor", "Component.focusedBorderColor", uiKeys );
+		defaults.put( "Button.hoverBorderColor", defaults.get( "Button.focusedBorderColor" ) );
+		defaults.put( "HelpButton.hoverBorderColor", defaults.get( "Button.focusedBorderColor" ) );
+
 		// IDEA uses a SVG icon for the help button, but paints the background with Button.startBackground and Button.endBackground
 		Object helpButtonBackground = defaults.get( "Button.startBackground" );
 		Object helpButtonBorderColor = defaults.get( "Button.startBorderColor" );
@@ -152,7 +184,7 @@ public class IntelliJTheme
 			helpButtonBorderColor = defaults.get( "Button.borderColor" );
 		defaults.put( "HelpButton.background", helpButtonBackground );
 		defaults.put( "HelpButton.borderColor", helpButtonBorderColor );
-		defaults.put( "HelpButton.disabledBackground", defaults.get( "Panel.background" ) );
+		defaults.put( "HelpButton.disabledBackground", panelBackground );
 		defaults.put( "HelpButton.disabledBorderColor", defaults.get( "Button.disabledBorderColor" ) );
 		defaults.put( "HelpButton.focusedBorderColor", defaults.get( "Button.focusedBorderColor" ) );
 		defaults.put( "HelpButton.focusedBackground", defaults.get( "Button.focusedBackground" ) );
@@ -183,6 +215,62 @@ public class IntelliJTheme
 			if( !uiKeys.contains( "Spinner.background" ) )
 				defaults.put( "Spinner.background", textFieldBackground );
 		}
+
+		// fix ToggleButton
+		if( !uiKeys.contains( "ToggleButton.startBackground" ) && !uiKeys.contains( "*.startBackground" ) )
+			defaults.put( "ToggleButton.startBackground", defaults.get( "Button.startBackground" ) );
+		if( !uiKeys.contains( "ToggleButton.endBackground" ) && !uiKeys.contains( "*.endBackground" ) )
+			defaults.put( "ToggleButton.endBackground", defaults.get( "Button.endBackground" ) );
+		if( !uiKeys.contains( "ToggleButton.foreground" ) && uiKeys.contains( "Button.foreground" ) )
+			defaults.put( "ToggleButton.foreground", defaults.get( "Button.foreground" ) );
+
+		// fix DesktopPane background (use Panel.background and make it 5% darker/lighter)
+		Color desktopBackgroundBase = defaults.getColor( "Panel.background" );
+		Color desktopBackground = ColorFunctions.applyFunctions( desktopBackgroundBase,
+			new ColorFunctions.HSLIncreaseDecrease( 2, dark, 5, false, true ) );
+		defaults.put( "Desktop.background", new ColorUIResource( desktopBackground ) );
+
+		// fix List and Table background colors in Material UI Lite themes
+		if( isMaterialUILite ) {
+			defaults.put( "List.background", defaults.get( "Tree.background" ) );
+			defaults.put( "Table.background", defaults.get( "Tree.background" ) );
+		}
+
+		// limit tree row height
+		int rowHeight = defaults.getInt( "Tree.rowHeight" );
+		if( rowHeight > 22 )
+			defaults.put( "Tree.rowHeight", 22 );
+
+		// apply theme specific UI defaults at the end to allow overwriting
+		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( ' ', '_' ) + ']';
+		String currentThemeAndAuthorPrefix = '[' + name.replace( ' ', '_' ) + "---" + author.replace( ' ', '_' ) + ']';
+		String currentAuthorPrefix = "[author-" + author.replace( ' ', '_' ) + ']';
+		String allThemesPrefix = "[*]";
+		String[] prefixes = { currentThemePrefix, currentThemeAndAuthorPrefix, currentAuthorPrefix, allThemesPrefix };
+		for( String key : themeSpecificKeys ) {
+			Object value = defaults.remove( key );
+			for( String prefix : prefixes ) {
+				if( key.startsWith( prefix ) ) {
+					themeSpecificDefaults.put( key.substring( prefix.length() ), value );
+					break;
+				}
+			}
+		}
+
+		return themeSpecificDefaults;
 	}
 
 	/**
@@ -200,7 +288,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 );
 			}
 		}
 	}
@@ -214,8 +302,15 @@ public class IntelliJTheme
 			for( Map.Entry<String, Object> e : ((Map<String, Object>)value).entrySet() )
 				apply( key + '.' + e.getKey(), e.getValue(), defaults, defaultsKeysCache, uiKeys );
 		} else {
+			if( "".equals( value ) )
+				return; // ignore empty value
+
 			uiKeys.add( key );
 
+			// fix ComboBox size and Spinner border in all Material UI Lite themes
+			if( isMaterialUILite && (key.equals( "ComboBox.padding" ) || key.equals( "Spinner.border" )) )
+				return; // ignore
+
 			// map keys
 			key = uiKeyMapping.getOrDefault( key, key );
 			if( key.isEmpty() )
@@ -245,7 +340,7 @@ public class IntelliJTheme
 				try {
 					uiValue = UIDefaultsLoader.parseValue( key, valueStr );
 				} catch( RuntimeException ex ) {
-					UIDefaultsLoader.logParseError( Level.CONFIG, key, valueStr, ex );
+					UIDefaultsLoader.logParseError( key, valueStr, ex, false );
 					return; // ignore invalid value
 				}
 			}
@@ -265,12 +360,16 @@ public class IntelliJTheme
 
 				// replace all values in UI defaults that match the wildcard key
 				for( Object k : defaultsKeysCache ) {
+					if( k.equals( "Desktop.background" ) ||
+						k.equals( "DesktopIcon.background" ) )
+					  continue;
+
 					if( k instanceof String ) {
 						// support replacing of mapped keys
 						// (e.g. set ComboBox.buttonEditableBackground to *.background
 						// because it is mapped from ComboBox.ArrowButton.background)
 						String km = uiKeyInverseMapping.getOrDefault( k, (String) k );
-						if( km.endsWith( tail ) && !noWildcardReplace.contains( k ) && !((String)k).startsWith( "CheckBox.icon." ) )
+						if( km.endsWith( tail ) && !((String)k).startsWith( "CheckBox.icon." ) )
 							defaults.put( k, uiValue );
 					}
 				}
@@ -324,7 +423,7 @@ public class IntelliJTheme
 	}
 
 	/**
-	 * Because IDEA uses SVGs for check boxes and radio buttons the colors for
+	 * Because IDEA uses SVGs for check boxes and radio buttons, the colors for
 	 * this two components are specified in "icons > ColorPalette".
 	 * FlatLaf uses vector icons and expects colors for the two components in UI defaults.
 	 */
@@ -362,6 +461,10 @@ public class IntelliJTheme
 
 			String newKey = checkboxKeyMapping.get( key );
 			if( newKey != null ) {
+				String checkBoxIconPrefix = "CheckBox.icon.";
+				if( !dark && newKey.startsWith( checkBoxIconPrefix ) )
+					newKey = "CheckBox.icon[filled].".concat( newKey.substring( checkBoxIconPrefix.length() ) );
+
 				ColorUIResource color = toColor( (String) value );
 				if( color != null ) {
 					defaults.put( newKey, color );
@@ -392,27 +495,51 @@ public class IntelliJTheme
 			}
 		}
 
-		// remove hover and pressed colors
+		// update hover, pressed and focused colors
 		if( checkboxModified ) {
-			defaults.remove( "CheckBox.icon.hoverBorderColor" );
-			defaults.remove( "CheckBox.icon.focusedBackground" );
-			defaults.remove( "CheckBox.icon.hoverBackground" );
-			defaults.remove( "CheckBox.icon.pressedBackground" );
-			defaults.remove( "CheckBox.icon.selectedHoverBackground" );
-			defaults.remove( "CheckBox.icon.selectedPressedBackground" );
-		}
+			// for non-filled checkbox/radiobutton used in dark themes
+			defaults.remove( "CheckBox.icon.focusWidth" );
+			defaults.put( "CheckBox.icon.hoverBorderColor", defaults.get( "CheckBox.icon.focusedBorderColor" ) );
 
-		// copy values
-		for( Map.Entry<String, String> e : uiKeyCopying.entrySet() )
-			defaults.put( e.getKey(), defaults.get( e.getValue() ) );
+			// for filled checkbox/radiobutton used in light themes
+			defaults.remove( "CheckBox.icon[filled].focusWidth" );
+			defaults.put( "CheckBox.icon[filled].hoverBorderColor", defaults.get( "CheckBox.icon[filled].focusedBorderColor" ) );
+			defaults.put( "CheckBox.icon[filled].selectedFocusedBackground", defaults.get( "CheckBox.icon[filled].selectedBackground" ) );
+
+			if( dark ) {
+				// IDEA Darcula checkBoxFocused.svg, checkBoxSelectedFocused.svg,
+				// radioFocused.svg and radioSelectedFocused.svg
+				// use opacity=".65" for the border
+				// --> add alpha to focused border colors
+				String[] focusedBorderColorKeys = new String[] {
+					"CheckBox.icon.focusedBorderColor",
+					"CheckBox.icon.selectedFocusedBorderColor",
+					"CheckBox.icon[filled].focusedBorderColor",
+					"CheckBox.icon[filled].selectedFocusedBorderColor",
+				};
+				for( String key : focusedBorderColorKeys ) {
+					Color color = defaults.getColor( key );
+					if( color != null ) {
+						defaults.put( key, new ColorUIResource( new Color(
+							(color.getRGB() & 0xffffff) | 0xa6000000, true ) ) );
+					}
+				}
+			}
+		}
 	}
 
+	private void copyIfNotSet( UIDefaults defaults, String destKey, String srcKey, Set<String> uiKeys ) {
+		if( !uiKeys.contains( destKey ) )
+			defaults.put( destKey, defaults.get( srcKey ) );
+	}
+
+	/** Rename UI default keys (key --> value). */
 	private static Map<String, String> uiKeyMapping = new HashMap<>();
+	/** Copy UI default keys (value --> key). */
 	private static Map<String, String> uiKeyCopying = new HashMap<>();
 	private static Map<String, String> uiKeyInverseMapping = new HashMap<>();
 	private static Map<String, String> checkboxKeyMapping = new HashMap<>();
 	private static Map<String, String> checkboxDuplicateColors = new HashMap<>();
-	private static Set<String> noWildcardReplace = new HashSet<>();
 
 	static {
 		// ComboBox
@@ -423,14 +550,36 @@ public class IntelliJTheme
 		uiKeyMapping.put( "ComboBox.ArrowButton.iconColor",             "ComboBox.buttonArrowColor" );
 		uiKeyMapping.put( "ComboBox.ArrowButton.nonEditableBackground", "ComboBox.buttonBackground" );
 
+		// Component
+		uiKeyMapping.put( "Component.inactiveErrorFocusColor",   "Component.error.borderColor" );
+		uiKeyMapping.put( "Component.errorFocusColor",           "Component.error.focusedBorderColor" );
+		uiKeyMapping.put( "Component.inactiveWarningFocusColor", "Component.warning.borderColor" );
+		uiKeyMapping.put( "Component.warningFocusColor",         "Component.warning.focusedBorderColor" );
+
 		// Link
 		uiKeyMapping.put( "Link.activeForeground", "Component.linkColor" );
 
+		// Menu
+		uiKeyMapping.put( "Menu.border",                "Menu.margin" );
+		uiKeyMapping.put( "MenuItem.border",            "MenuItem.margin" );
+		uiKeyCopying.put( "CheckBoxMenuItem.margin",    "MenuItem.margin" );
+		uiKeyCopying.put( "RadioButtonMenuItem.margin", "MenuItem.margin" );
+		uiKeyMapping.put( "PopupMenu.border",           "PopupMenu.borderInsets" );
+		uiKeyCopying.put( "MenuItem.underlineSelectionColor", "TabbedPane.underlineColor" );
+
+		// IDEA uses List.selectionBackground also for menu selection
+		uiKeyCopying.put( "Menu.selectionBackground",                "List.selectionBackground" );
+		uiKeyCopying.put( "MenuItem.selectionBackground",            "List.selectionBackground" );
+		uiKeyCopying.put( "CheckBoxMenuItem.selectionBackground",    "List.selectionBackground" );
+		uiKeyCopying.put( "RadioButtonMenuItem.selectionBackground", "List.selectionBackground" );
+
 		// ProgressBar
 		uiKeyMapping.put( "ProgressBar.background",    "" ); // ignore
 		uiKeyMapping.put( "ProgressBar.foreground",    "" ); // ignore
 		uiKeyMapping.put( "ProgressBar.trackColor",    "ProgressBar.background" );
 		uiKeyMapping.put( "ProgressBar.progressColor", "ProgressBar.foreground" );
+		uiKeyCopying.put( "ProgressBar.selectionForeground", "ProgressBar.background" );
+		uiKeyCopying.put( "ProgressBar.selectionBackground", "ProgressBar.foreground" );
 
 		// ScrollBar
 		uiKeyMapping.put( "ScrollBar.trackColor", "ScrollBar.track" );
@@ -441,6 +590,14 @@ public class IntelliJTheme
 
 		// Slider
 		uiKeyMapping.put( "Slider.trackWidth", "" ); // ignore (used in Material Theme UI Lite)
+		uiKeyCopying.put( "Slider.trackValueColor", "ProgressBar.foreground" );
+		uiKeyCopying.put( "Slider.thumbColor", "ProgressBar.foreground" );
+		uiKeyCopying.put( "Slider.trackColor", "ProgressBar.background" );
+
+		// TitlePane
+		uiKeyCopying.put( "TitlePane.inactiveBackground",     "TitlePane.background" );
+		uiKeyMapping.put( "TitlePane.infoForeground",         "TitlePane.foreground" );
+		uiKeyMapping.put( "TitlePane.inactiveInfoForeground", "TitlePane.inactiveForeground" );
 
 		for( Map.Entry<String, String> e : uiKeyMapping.entrySet() )
 			uiKeyInverseMapping.put( e.getValue(), e.getKey() );
@@ -456,7 +613,7 @@ public class IntelliJTheme
 		checkboxKeyMapping.put( "Checkbox.Border.Default",      "CheckBox.icon.borderColor" );
 		checkboxKeyMapping.put( "Checkbox.Border.Disabled",     "CheckBox.icon.disabledBorderColor" );
 		checkboxKeyMapping.put( "Checkbox.Focus.Thin.Default",  "CheckBox.icon.focusedBorderColor" );
-		checkboxKeyMapping.put( "Checkbox.Focus.Wide",          "CheckBox.icon.focusedColor" );
+		checkboxKeyMapping.put( "Checkbox.Focus.Wide",          "CheckBox.icon.focusColor" );
 		checkboxKeyMapping.put( "Checkbox.Foreground.Disabled", "CheckBox.icon.disabledCheckmarkColor" );
 		checkboxKeyMapping.put( "Checkbox.Background.Selected", "CheckBox.icon.selectedBackground" );
 		checkboxKeyMapping.put( "Checkbox.Border.Selected",     "CheckBox.icon.selectedBorderColor" );
@@ -470,16 +627,6 @@ public class IntelliJTheme
 		Map.Entry<String, String>[] entries = checkboxDuplicateColors.entrySet().toArray( new Map.Entry[checkboxDuplicateColors.size()] );
 		for( Map.Entry<String, String> e : entries )
 			checkboxDuplicateColors.put( e.getValue(), e.getKey() );
-
-		// because FlatLaf uses Button.background and Button.borderColor,
-		// but IDEA uses Button.startBackground and Button.startBorderColor,
-		// our default button background and border colors may be replaced by
-		// wildcard *.background and *.borderColor colors
-		noWildcardReplace.add( "Button.background" );
-		noWildcardReplace.add( "Button.borderColor" );
-		noWildcardReplace.add( "Button.default.background" );
-		noWildcardReplace.add( "Button.default.borderColor" );
-		noWildcardReplace.add( "ToggleButton.background" );
 	}
 
 	//---- class ThemeLaf -----------------------------------------------------
@@ -500,7 +647,7 @@ public class IntelliJTheme
 
 		@Override
 		public String getDescription() {
-			return theme.name;
+			return getName();
 		}
 
 		@Override

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

@@ -28,7 +28,8 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.StringTokenizer;
-import java.util.logging.Level;
+
+import com.formdev.flatlaf.util.LoggingFacade;
 import com.formdev.flatlaf.util.StringUtils;
 import com.formdev.flatlaf.util.SystemInfo;
 import com.formdev.flatlaf.util.UIScale;
@@ -39,7 +40,7 @@ import com.formdev.flatlaf.util.UIScale;
 class LinuxFontPolicy
 {
 	static Font getFont() {
-		return SystemInfo.IS_KDE ? getKDEFont() : getGnomeFont();
+		return SystemInfo.isKDE ? getKDEFont() : getGnomeFont();
 	}
 
 	/**
@@ -54,29 +55,50 @@ class LinuxFontPolicy
 
 		String family = "";
 		int style = Font.PLAIN;
-		int size = 10;
+		double dsize = 10;
 
+		// parse pango font description
+		// see https://developer.gnome.org/pango/1.46/pango-Fonts.html#pango-font-description-from-string
 		StringTokenizer st = new StringTokenizer( (String) fontName );
 		while( st.hasMoreTokens() ) {
 			String word = st.nextToken();
 
-			if( word.equalsIgnoreCase( "italic" ) )
+			// remove trailing ',' (e.g. in "Ubuntu Condensed, 11" or "Ubuntu Condensed, Bold 11")
+			if( word.endsWith( "," ) )
+				word = word.substring( 0, word.length() - 1 ).trim();
+
+			String lword = word.toLowerCase();
+			if( lword.equals( "italic" ) || lword.equals( "oblique" ) )
 				style |= Font.ITALIC;
-			else if( word.equalsIgnoreCase( "bold" ) )
+			else if( lword.equals( "bold" ) )
 				style |= Font.BOLD;
 			else if( Character.isDigit( word.charAt( 0 ) ) ) {
 				try {
-					size = Integer.parseInt( word );
+					dsize = Double.parseDouble( word );
 				} catch( NumberFormatException ex ) {
 					// ignore
 				}
-			} else
+			} else {
+				// remove '-' from "Semi-Bold", "Extra-Light", etc
+				if( lword.startsWith( "semi-" ) || lword.startsWith( "demi-" ) )
+					word = word.substring( 0, 4 ) + word.substring( 5 );
+				else if( lword.startsWith( "extra-" ) || lword.startsWith( "ultra-" ) )
+					word = word.substring( 0, 5 ) + word.substring( 6 );
+
 				family = family.isEmpty() ? word : (family + ' ' + word);
+			}
 		}
 
+		// Ubuntu font is rendered poorly (except if running in JetBrains VM)
+		// --> use Liberation Sans font
+		if( family.startsWith( "Ubuntu" ) &&
+			!SystemInfo.isJetBrainsJVM &&
+			!FlatSystemProperties.getBoolean( FlatSystemProperties.USE_UBUNTU_FONT, false ) )
+		  family = "Liberation Sans";
+
 		// scale font size
-		double dsize = size * getGnomeFontScale();
-		size = (int) (dsize + 0.5);
+		dsize *= getGnomeFontScale();
+		int size = (int) (dsize + 0.5);
 		if( size < 1 )
 			size = 1;
 
@@ -85,7 +107,37 @@ class LinuxFontPolicy
 		if( logicalFamily != null )
 			family = logicalFamily;
 
-		return createFont( family, style, size, dsize );
+		return createFontEx( family, style, size, dsize );
+	}
+
+	/**
+	 * Create a font for the given family, style and size.
+	 * If the font family does not match any font on the system,
+	 * then the last word (usually a font weight) from the family name is removed and tried again.
+	 * E.g. family 'URW Bookman Light' is not found, but 'URW Bookman' is found.
+	 * If still not found, then font of family 'Dialog' is returned.
+	 */
+	private static Font createFontEx( String family, int style, int size, double dsize ) {
+		for(;;) {
+			Font font = createFont( family, style, size, dsize );
+
+			// if the font family does not match any font on the system, "Dialog" family is returned
+			if( !"Dialog".equals( font.getFamily() ) || "Dialog".equals( family ) )
+				return font;
+
+			// find last word in family
+			int index = family.lastIndexOf( ' ' );
+			if( index < 0 )
+				return createFont( "Dialog", style, size, dsize );
+
+			// check whether last work contains some font weight (e.g. Ultra-Bold or Heavy)
+			String lastWord = family.substring( index + 1 ).toLowerCase();
+			if( lastWord.contains( "bold" ) || lastWord.contains( "heavy" ) || lastWord.contains( "black" ) )
+				style |= Font.BOLD;
+
+			// remove last word from family and try again
+			family = family.substring( 0, index );
+		}
 	}
 
 	private static Font createFont( String family, int style, int size, double dsize ) {
@@ -165,7 +217,7 @@ class LinuxFontPolicy
 				if( "1".equals( strs.get( 5 ) ) )
 					style |= Font.ITALIC;
 			} catch( RuntimeException ex ) {
-				FlatLaf.LOG.log( Level.CONFIG, "FlatLaf: Failed to parse 'font=" + generalFont + "'.", ex );
+				LoggingFacade.INSTANCE.logConfig( "FlatLaf: Failed to parse 'font=" + generalFont + "'.", ex );
 			}
 		}
 
@@ -179,7 +231,7 @@ class LinuxFontPolicy
 				if( dpi < 50 )
 					dpi = 50;
 			} catch( NumberFormatException ex ) {
-				FlatLaf.LOG.log( Level.CONFIG, "FlatLaf: Failed to parse 'forceFontDPI=" + forceFontDPI + "'.", ex );
+				LoggingFacade.INSTANCE.logConfig( "FlatLaf: Failed to parse 'forceFontDPI=" + forceFontDPI + "'.", ex );
 			}
 		}
 
@@ -218,7 +270,7 @@ class LinuxFontPolicy
 			while( (line = reader.readLine()) != null )
 				lines.add( line );
 		} catch( IOException ex ) {
-			FlatLaf.LOG.log( Level.CONFIG, "FlatLaf: Failed to read '" + filename + "'.", ex );
+			LoggingFacade.INSTANCE.logConfig( "FlatLaf: Failed to read '" + filename + "'.", ex );
 		}
 		return lines;
 	}
@@ -257,6 +309,9 @@ class LinuxFontPolicy
 	 *   - running on JetBrains Runtime 11 or later and scaling is enabled in system Settings
 	 */
 	private static boolean isSystemScaling() {
+		if( GraphicsEnvironment.isHeadless() )
+			return true;
+
 		GraphicsConfiguration gc = GraphicsEnvironment.getLocalGraphicsEnvironment()
 			.getDefaultScreenDevice().getDefaultConfiguration();
 		return UIScale.getSystemScaleFactor( gc ) > 1;

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

@@ -0,0 +1,267 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf;
+
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.EventQueue;
+import java.awt.KeyEventPostProcessor;
+import java.awt.KeyboardFocusManager;
+import java.awt.Window;
+import java.awt.event.KeyEvent;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
+import java.lang.ref.WeakReference;
+import javax.swing.AbstractButton;
+import javax.swing.JDialog;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JRootPane;
+import javax.swing.JTabbedPane;
+import javax.swing.MenuElement;
+import javax.swing.MenuSelectionManager;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import com.formdev.flatlaf.util.SystemInfo;
+
+/**
+ * Show/hide mnemonics.
+ *
+ * @author Karl Tauber
+ */
+class MnemonicHandler
+	implements KeyEventPostProcessor, ChangeListener
+{
+	private static boolean showMnemonics;
+	private static WeakReference<Window> lastShowMnemonicWindow;
+	private static WindowListener windowListener;
+
+	static boolean isShowMnemonics() {
+		return showMnemonics || !UIManager.getBoolean( "Component.hideMnemonics" );
+	}
+
+	void install() {
+		KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventPostProcessor( this );
+		MenuSelectionManager.defaultManager().addChangeListener( this );
+	}
+
+	void uninstall() {
+		KeyboardFocusManager.getCurrentKeyboardFocusManager().removeKeyEventPostProcessor( this );
+		MenuSelectionManager.defaultManager().removeChangeListener( this );
+	}
+
+	@Override
+	public boolean postProcessKeyEvent( KeyEvent e ) {
+		int keyCode = e.getKeyCode();
+		if( SystemInfo.isMacOS ) {
+			// Ctrl+Alt keys must be pressed on Mac
+			if( keyCode == KeyEvent.VK_CONTROL || keyCode == KeyEvent.VK_ALT )
+				showMnemonics( shouldShowMnemonics( e ) && e.isControlDown() && e.isAltDown(), e.getComponent() );
+		} else {
+			// Alt key must be pressed on Windows and Linux
+			if( SystemInfo.isWindows )
+				return processKeyEventOnWindows( e );
+
+			if( keyCode == KeyEvent.VK_ALT )
+				showMnemonics( shouldShowMnemonics( e ), e.getComponent() );
+		}
+
+		return false;
+	}
+
+	private boolean shouldShowMnemonics( KeyEvent e ) {
+		return e.getID() == KeyEvent.KEY_PRESSED ||
+			MenuSelectionManager.defaultManager().getSelectedPath().length > 0;
+	}
+
+	private static int altPressedEventCount;
+	private static boolean selectMenuOnAltReleased;
+
+	/**
+	 * Special Alt key behavior on Windows.
+	 *
+	 * Press-and-release Alt key selects first menu (if available) and moves focus
+	 * temporary to menu bar. If menu bar has focus (some menu is selected),
+	 * pressing Alt key unselects menu and moves focus back to permanent focus owner.
+	 */
+	private boolean processKeyEventOnWindows( KeyEvent e ) {
+		if( e.getKeyCode() != KeyEvent.VK_ALT ) {
+			selectMenuOnAltReleased = false;
+			return false;
+		}
+
+		if( e.getID() == KeyEvent.KEY_PRESSED ) {
+			altPressedEventCount++;
+
+			if( altPressedEventCount == 1 && !e.isConsumed() ) {
+				MenuSelectionManager menuSelectionManager = MenuSelectionManager.defaultManager();
+				selectMenuOnAltReleased = (menuSelectionManager.getSelectedPath().length == 0);
+
+				// if menu is selected when Alt key is pressed then clear menu selection
+				if( !selectMenuOnAltReleased )
+					menuSelectionManager.clearSelectedPath();
+			}
+
+			// show mnemonics
+			showMnemonics( shouldShowMnemonics( e ), e.getComponent() );
+
+			// avoid that the system menu of the window gets focus
+			e.consume();
+			return true;
+
+		} else if( e.getID() == KeyEvent.KEY_RELEASED ) {
+			altPressedEventCount = 0;
+
+			boolean mnemonicsShown = false;
+			if( selectMenuOnAltReleased && !e.isConsumed() ) {
+				MenuSelectionManager menuSelectionManager = MenuSelectionManager.defaultManager();
+				if( menuSelectionManager.getSelectedPath().length == 0 ) {
+					// get menu bar and first menu
+					Component c = e.getComponent();
+					JRootPane rootPane = SwingUtilities.getRootPane( c );
+					JMenuBar menuBar = (rootPane != null) ? rootPane.getJMenuBar() : null;
+					if( menuBar == null ) {
+						// get menu bar from frame/dialog because there
+						// may be multiple nested root panes in a frame/dialog
+						// (e.g. each internal frame has its own root pane)
+						Window window = SwingUtilities.getWindowAncestor( c );
+						if( window instanceof JFrame )
+							menuBar = ((JFrame)window).getJMenuBar();
+						else if( window instanceof JDialog )
+							menuBar = ((JDialog)window).getJMenuBar();
+					}
+					JMenu firstMenu = (menuBar != null) ? menuBar.getMenu( 0 ) : null;
+
+					// select first menu and show mnemonics
+					if( firstMenu != null ) {
+						menuSelectionManager.setSelectedPath( new MenuElement[] { menuBar, firstMenu } );
+						showMnemonics( true, c );
+						mnemonicsShown = true;
+					}
+				}
+			}
+			selectMenuOnAltReleased = false;
+
+			// hide mnemonics
+			if( !mnemonicsShown )
+				showMnemonics( shouldShowMnemonics( e ), e.getComponent() );
+		}
+		return false;
+	}
+
+	@Override
+	public void stateChanged( ChangeEvent e ) {
+		MenuElement[] selectedPath = MenuSelectionManager.defaultManager().getSelectedPath();
+		if( selectedPath.length == 0 && altPressedEventCount == 0 ) {
+			// hide mnemonics when menu selection was canceled
+			showMnemonics( false, null );
+		}
+	}
+
+	static void showMnemonics( boolean show, Component c ) {
+		if( show == showMnemonics )
+			return;
+
+		showMnemonics = show;
+
+		// check whether it is necessary to repaint
+		if( !UIManager.getBoolean( "Component.hideMnemonics" ) )
+			return;
+
+		if( show ) {
+			// get root pane
+			JRootPane rootPane = SwingUtilities.getRootPane( c );
+			if( rootPane == null )
+				return;
+
+			// get window
+			Window window = SwingUtilities.getWindowAncestor( rootPane );
+			if( window == null )
+				return;
+
+			// repaint components with mnemonics in focused window
+			repaintMnemonics( window );
+
+			// hide mnemonics if window is deactivated (e.g. Alt+Tab to another window)
+			windowListener = new WindowAdapter() {
+				@Override
+				public void windowDeactivated( WindowEvent e ) {
+					altPressedEventCount = 0;
+					selectMenuOnAltReleased = false;
+
+					// use invokeLater() to avoid that the listener is removed
+					// while the listener queue is iterated to fire this event
+					EventQueue.invokeLater( () -> {
+						showMnemonics( false, null );
+					} );
+				}
+			};
+			window.addWindowListener( windowListener );
+
+			lastShowMnemonicWindow = new WeakReference<>( window );
+		} else if( lastShowMnemonicWindow != null ) {
+			Window window = lastShowMnemonicWindow.get();
+			if( window != null ) {
+				repaintMnemonics( window );
+
+				if( windowListener != null ) {
+					window.removeWindowListener( windowListener );
+					windowListener = null;
+				}
+			}
+
+			lastShowMnemonicWindow = null;
+		}
+	}
+
+	private static void repaintMnemonics( Container container ) {
+		for( Component c : container.getComponents() ) {
+			if( !c.isVisible() )
+				continue;
+
+			if( hasMnemonic( c ) )
+				c.repaint();
+
+			if( c instanceof Container )
+				repaintMnemonics( (Container) c );
+		}
+	}
+
+	private static boolean hasMnemonic( Component c ) {
+		if( c instanceof JLabel && ((JLabel)c).getDisplayedMnemonicIndex() >= 0 )
+			return true;
+
+		if( c instanceof AbstractButton && ((AbstractButton)c).getDisplayedMnemonicIndex() >= 0 )
+			return true;
+
+		if( c instanceof JTabbedPane ) {
+			JTabbedPane tabPane = (JTabbedPane) c;
+			int tabCount = tabPane.getTabCount();
+			for( int i = 0; i < tabCount; i++ ) {
+				if( tabPane.getDisplayedMnemonicIndexAt( i ) >= 0 )
+					return true;
+			}
+		}
+
+		return false;
+	}
+}

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

@@ -19,17 +19,20 @@ package com.formdev.flatlaf;
 import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.Insets;
+import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Properties;
 import java.util.function.Function;
-import java.util.logging.Level;
 import javax.swing.UIDefaults;
 import javax.swing.UIManager;
 import javax.swing.UIDefaults.ActiveValue;
@@ -40,8 +43,11 @@ import javax.swing.plaf.InsetsUIResource;
 import com.formdev.flatlaf.ui.FlatEmptyBorder;
 import com.formdev.flatlaf.ui.FlatLineBorder;
 import com.formdev.flatlaf.util.ColorFunctions;
+import com.formdev.flatlaf.util.ColorFunctions.ColorFunction;
 import com.formdev.flatlaf.util.DerivedColor;
+import com.formdev.flatlaf.util.GrayFilter;
 import com.formdev.flatlaf.util.HSLColor;
+import com.formdev.flatlaf.util.LoggingFacade;
 import com.formdev.flatlaf.util.StringUtils;
 import com.formdev.flatlaf.util.SystemInfo;
 import com.formdev.flatlaf.util.UIScale;
@@ -62,14 +68,14 @@ 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 = "*.";
+	private static final String WILDCARD_PREFIX = "*.";
+
+	private static int parseColorDepth;
 
 	static void loadDefaultsFromProperties( Class<?> lookAndFeelClass, List<FlatDefaultsAddon> addons,
-		Properties additionalDefaults, UIDefaults defaults )
+		Properties additionalDefaults, boolean dark, UIDefaults defaults )
 	{
 		// determine classes in class hierarchy in reverse order
 		ArrayList<Class<?>> lafClasses = new ArrayList<>();
@@ -80,11 +86,11 @@ class UIDefaultsLoader
 			lafClasses.add( 0, lafClass );
 		}
 
-		loadDefaultsFromProperties( lafClasses, addons, additionalDefaults, defaults );
+		loadDefaultsFromProperties( lafClasses, addons, additionalDefaults, dark, defaults );
 	}
 
 	static void loadDefaultsFromProperties( List<Class<?>> lafClasses, List<FlatDefaultsAddon> addons,
-		Properties additionalDefaults, UIDefaults defaults )
+		Properties additionalDefaults, boolean dark, UIDefaults defaults )
 	{
 		try {
 			// load core properties files
@@ -115,24 +121,78 @@ class UIDefaultsLoader
 					addonClassLoaders.add( addonClassLoader );
 			}
 
+			// load custom properties files (usually provided by applications)
+			List<Object> customDefaultsSources = FlatLaf.getCustomDefaultsSources();
+			int size = (customDefaultsSources != null) ? customDefaultsSources.size() : 0;
+			for( int i = 0; i < size; i++ ) {
+				Object source = customDefaultsSources.get( i );
+				if( source instanceof String && i + 1 < size ) {
+					// load from package in classloader
+					String packageName = (String) source;
+					ClassLoader classLoader = (ClassLoader) customDefaultsSources.get( ++i );
+
+					// use class loader also for instantiating classes specified in values
+					if( classLoader != null && !addonClassLoaders.contains( classLoader ) )
+						addonClassLoaders.add( classLoader );
+
+					packageName = packageName.replace( '.', '/' );
+					if( classLoader == null )
+						classLoader = FlatLaf.class.getClassLoader();
+
+					for( Class<?> lafClass : lafClasses ) {
+						String propertiesName = packageName + '/' + lafClass.getSimpleName() + ".properties";
+						try( InputStream in = classLoader.getResourceAsStream( propertiesName ) ) {
+							if( in != null )
+								properties.load( in );
+						}
+					}
+				} else if( source instanceof File ) {
+					// load from folder
+					File folder = (File) source;
+					for( Class<?> lafClass : lafClasses ) {
+						File propertiesFile = new File( folder, lafClass.getSimpleName() + ".properties" );
+						if( !propertiesFile.isFile() )
+							continue;
+
+						try( InputStream in = new FileInputStream( propertiesFile ) ) {
+							properties.load( in );
+						}
+					}
+				}
+			}
+
 			// 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]" :
-					SystemInfo.IS_LINUX ? "[linux]" : "[unknown]";
+					SystemInfo.isWindows ? "[win]" :
+					SystemInfo.isMacOS ? "[mac]" :
+					SystemInfo.isLinux ? "[linux]" : "[unknown]";
 				for( String key : platformSpecificKeys ) {
 					Object value = properties.remove( key );
 					if( key.startsWith( platformPrefix ) )
@@ -140,77 +200,81 @@ class UIDefaultsLoader
 				}
 			}
 
+			// get (and remove) wildcard replacements, which override all other defaults that end with same suffix
+			HashMap<String, String> wildcards = new HashMap<>();
+			Iterator<Entry<Object, Object>> it = properties.entrySet().iterator();
+			while( it.hasNext() ) {
+				Entry<Object, Object> e = it.next();
+				String key = (String) e.getKey();
+				if( key.startsWith( WILDCARD_PREFIX ) ) {
+					wildcards.put( key.substring( WILDCARD_PREFIX.length() ), (String) e.getValue() );
+					it.remove();
+				}
+			}
+
+			// override UI defaults with wildcard replacements
+			for( Object key : defaults.keySet() ) {
+				int dot;
+				if( !(key instanceof String) ||
+					properties.containsKey( key ) ||
+					(dot = ((String)key).lastIndexOf( '.' )) < 0 )
+				  continue;
+
+				String wildcardKey = ((String)key).substring( dot + 1 );
+				String wildcardValue = wildcards.get( wildcardKey );
+				if( wildcardValue != null )
+					properties.put( key, wildcardValue );
+			}
+
+			Function<String, String> propertiesGetter = key -> {
+				return properties.getProperty( key );
+			};
 			Function<String, String> resolver = value -> {
-				return resolveValue( properties, value );
+				return resolveValue( value, propertiesGetter );
 			};
 
-			// get globals, which override all other defaults that end with same suffix
-			HashMap<String, Object> globals = new HashMap<>();
+			// parse and add properties to UI defaults
 			for( Map.Entry<Object, Object> e : properties.entrySet() ) {
 				String key = (String) e.getKey();
-				if( !key.startsWith( GLOBAL_PREFIX ) )
+				if( key.startsWith( VARIABLE_PREFIX ) )
 					continue;
 
-				String value = resolveValue( properties, (String) e.getValue() );
+				String value = resolveValue( (String) e.getValue(), propertiesGetter );
 				try {
-					globals.put( key.substring( GLOBAL_PREFIX.length() ), parseValue( key, value, resolver, addonClassLoaders ) );
+					defaults.put( key, parseValue( key, value, null, resolver, addonClassLoaders ) );
 				} catch( RuntimeException ex ) {
-					logParseError( Level.SEVERE, key, value, ex );
-				}
-			}
-
-			// override UI defaults with globals
-			for( Object key : defaults.keySet() ) {
-				if( key instanceof String && ((String)key).contains( "." ) ) {
-					String skey = (String) key;
-					String globalKey = skey.substring( skey.lastIndexOf( '.' ) + 1 );
-					Object globalValue = globals.get( globalKey );
-					if( globalValue != null )
-						defaults.put( key, globalValue );
-				}
-			}
-
-			// add non-global properties to UI defaults
-			for( Map.Entry<Object, Object> e : properties.entrySet() ) {
-				String key = (String) e.getKey();
-				if( key.startsWith( VARIABLE_PREFIX ) || key.startsWith( GLOBAL_PREFIX ) )
-					continue;
-
-				String value = resolveValue( properties, (String) e.getValue() );
-				try {
-					defaults.put( key, parseValue( key, value, resolver, addonClassLoaders ) );
-				} catch( RuntimeException ex ) {
-					logParseError( Level.SEVERE, key, value, ex );
+					logParseError( key, value, ex, true );
 				}
 			}
 		} catch( IOException ex ) {
-			FlatLaf.LOG.log( Level.SEVERE, "FlatLaf: Failed to load properties files.", ex );
+			LoggingFacade.INSTANCE.logSevere( "FlatLaf: Failed to load properties files.", ex );
 		}
 	}
 
-	static void logParseError( Level level, String key, String value, RuntimeException ex ) {
-		FlatLaf.LOG.log( level, "FlatLaf: Failed to parse: '" + key + '=' + value + '\'', ex );
+	static void logParseError( String key, String value, RuntimeException ex, boolean severe ) {
+		String message = "FlatLaf: Failed to parse: '" + key + '=' + value + '\'';
+		if( severe )
+			LoggingFacade.INSTANCE.logSevere( message, ex );
+		else
+			LoggingFacade.INSTANCE.logConfig( message, ex );
 	}
 
-	private static String resolveValue( Properties properties, String value ) {
+	static String resolveValue( String value, Function<String, String> propertiesGetter ) {
+		value = value.trim();
+		String value0 = value;
+
 		if( value.startsWith( PROPERTY_PREFIX ) )
 			value = value.substring( PROPERTY_PREFIX.length() );
 		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() );
 			optional = true;
 		}
 
-		String newValue = properties.getProperty( value );
+		String newValue = propertiesGetter.apply( value );
 		if( newValue == null ) {
 			if( optional )
 				return "null";
@@ -218,29 +282,40 @@ class UIDefaultsLoader
 			throw new IllegalArgumentException( "variable or property '" + value + "' not found" );
 		}
 
-		return resolveValue( properties, newValue );
+		if( newValue.equals( value0 ) )
+			throw new IllegalArgumentException( "endless recursion in variable or property '" + value + "'" );
+
+		return resolveValue( newValue, propertiesGetter );
 	}
 
-	private enum ValueType { UNKNOWN, STRING, CHARACTER, INTEGER, FLOAT, BORDER, ICON, INSETS, DIMENSION, COLOR,
-		SCALEDINTEGER, SCALEDFLOAT, SCALEDINSETS, SCALEDDIMENSION, INSTANCE, CLASS }
+	enum ValueType { UNKNOWN, STRING, BOOLEAN, CHARACTER, INTEGER, FLOAT, BORDER, ICON, INSETS, DIMENSION, COLOR,
+		SCALEDINTEGER, SCALEDFLOAT, SCALEDINSETS, SCALEDDIMENSION, INSTANCE, CLASS, GRAYFILTER, NULL, LAZY }
+
+	private static ValueType[] tempResultValueType = new ValueType[1];
 
 	static Object parseValue( String key, String value ) {
-		return parseValue( key, value, v -> v, Collections.emptyList() );
+		return parseValue( key, value, null, v -> v, Collections.emptyList() );
 	}
 
-	private static Object parseValue( String key, String value, Function<String, String> resolver, List<ClassLoader> addonClassLoaders ) {
+	static Object parseValue( String key, String value, ValueType[] resultValueType,
+		Function<String, String> resolver, List<ClassLoader> addonClassLoaders )
+	{
+		if( resultValueType == null )
+			resultValueType = tempResultValueType;
+
 		value = value.trim();
 
 		// null, false, true
 		switch( value ) {
-			case "null":	return null;
-			case "false":	return false;
-			case "true":	return true;
+			case "null":	resultValueType[0] = ValueType.NULL; return null;
+			case "false":	resultValueType[0] = ValueType.BOOLEAN; return false;
+			case "true":	resultValueType[0] = ValueType.BOOLEAN; return true;
 		}
 
 		// check for function "lazy"
 		//     Syntax: lazy(uiKey)
 		if( value.startsWith( "lazy(" ) && value.endsWith( ")" ) ) {
+			resultValueType[0] = ValueType.LAZY;
 			String uiKey = value.substring( 5, value.length() - 1 ).trim();
 			return (LazyValue) t -> {
 				return lazyUIManagerGet( uiKey );
@@ -272,7 +347,12 @@ class UIDefaultsLoader
 
 		// determine value type from key
 		if( valueType == ValueType.UNKNOWN ) {
-			if( key.endsWith( "ground" ) || key.endsWith( "Color" ) )
+			if( key.endsWith( "UI" ) )
+				valueType = ValueType.STRING;
+			else if( key.endsWith( "Color" ) ||
+				(key.endsWith( "ground" ) &&
+				 (key.endsWith( ".background" ) || key.endsWith( "Background" ) ||
+				  key.endsWith( ".foreground" ) || key.endsWith( "Foreground" ))) )
 				valueType = ValueType.COLOR;
 			else if( key.endsWith( ".border" ) || key.endsWith( "Border" ) )
 				valueType = ValueType.BORDER;
@@ -287,10 +367,12 @@ class UIDefaultsLoader
 				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;
 		}
 
+		resultValueType[0] = valueType;
+
 		// parse value
 		switch( valueType ) {
 			case STRING:		return value;
@@ -308,24 +390,32 @@ class UIDefaultsLoader
 			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
 				Object color = parseColorOrFunction( value, resolver, false );
-				if( color != null )
+				if( color != null ) {
+					resultValueType[0] = ValueType.COLOR;
 					return color;
+				}
 
 				// integer
 				Integer integer = parseInteger( value, false );
-				if( integer != null )
+				if( integer != null ) {
+					resultValueType[0] = ValueType.INTEGER;
 					return integer;
+				}
 
 				// float
 				Float f = parseFloat( value, false );
-				if( f != null )
+				if( f != null ) {
+					resultValueType[0] = ValueType.FLOAT;
 					return f;
+				}
 
 				// string
+				resultValueType[0] = ValueType.STRING;
 				return value;
 		}
 	}
@@ -352,9 +442,9 @@ class UIDefaultsLoader
 	private static Object parseInstance( String value, List<ClassLoader> addonClassLoaders ) {
 		return (LazyValue) t -> {
 			try {
-				return findClass( value, addonClassLoaders ).newInstance();
-			} catch( InstantiationException | IllegalAccessException | ClassNotFoundException ex ) {
-				FlatLaf.LOG.log( Level.SEVERE, "FlatLaf: Failed to instantiate '" + value + "'.", ex );
+				return findClass( value, addonClassLoaders ).getDeclaredConstructor().newInstance();
+			} catch( Exception ex ) {
+				LoggingFacade.INSTANCE.logSevere( "FlatLaf: Failed to instantiate '" + value + "'.", ex );
 				return null;
 			}
 		};
@@ -365,7 +455,7 @@ class UIDefaultsLoader
 			try {
 				return findClass( value, addonClassLoaders );
 			} catch( ClassNotFoundException ex ) {
-				FlatLaf.LOG.log( Level.SEVERE, "FlatLaf: Failed to find class '" + value + "'.", ex );
+				LoggingFacade.INSTANCE.logSevere( "FlatLaf: Failed to find class '" + value + "'.", ex );
 				return null;
 			}
 		};
@@ -496,13 +586,34 @@ class UIDefaultsLoader
 		if( params.isEmpty() )
 			throw new IllegalArgumentException( "missing parameters in function '" + value + "'" );
 
-		switch( function ) {
-			case "rgb":			return parseColorRgbOrRgba( false, params );
-			case "rgba":		return parseColorRgbOrRgba( true, params );
-			case "hsl":			return parseColorHslOrHsla( false, params );
-			case "hsla":		return parseColorHslOrHsla( true, params );
-			case "lighten":		return parseColorLightenOrDarken( true, params, resolver, reportError );
-			case "darken":		return parseColorLightenOrDarken( false, params, resolver, reportError );
+		if( parseColorDepth > 100 )
+			throw new IllegalArgumentException( "endless recursion in color function '" + value + "'" );
+
+		parseColorDepth++;
+		try {
+			switch( function ) {
+				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 parseColorHSLIncreaseDecrease( 2, true, params, resolver, reportError );
+				case "darken":		return parseColorHSLIncreaseDecrease( 2, false, params, resolver, reportError );
+				case "saturate":	return parseColorHSLIncreaseDecrease( 1, true, params, resolver, reportError );
+				case "desaturate":	return parseColorHSLIncreaseDecrease( 1, false, params, resolver, reportError );
+				case "fadein":		return parseColorHSLIncreaseDecrease( 3, true, params, resolver, reportError );
+				case "fadeout":		return parseColorHSLIncreaseDecrease( 3, false, params, resolver, reportError );
+				case "fade":		return parseColorFade( params, resolver, reportError );
+				case "spin":		return parseColorSpin( params, resolver, reportError );
+				case "changeHue":		return parseColorChange( 0, params, resolver, reportError );
+				case "changeSaturation":return parseColorChange( 1, params, resolver, reportError );
+				case "changeLightness":	return parseColorChange( 2, params, resolver, reportError );
+				case "changeAlpha":		return parseColorChange( 3, params, resolver, reportError );
+				case "mix":				return parseColorMix( null, params, resolver, reportError );
+				case "tint":			return parseColorMix( "#fff", params, resolver, reportError );
+				case "shade":			return parseColorMix( "#000", params, resolver, reportError );
+			}
+		} finally {
+			parseColorDepth--;
 		}
 
 		throw new IllegalArgumentException( "unknown color function '" + value + "'" );
@@ -510,16 +621,29 @@ 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
+	 *   - 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
+			// NOTE: this syntax is deprecated
+			//       use fade(color,alpha) instead
+			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 ) )
@@ -534,7 +658,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;
@@ -544,35 +668,38 @@ class UIDefaultsLoader
 	}
 
 	/**
-	 * Syntax: lighten([color,]amount[,options]) or darken([color,]amount[,options])
+	 * Syntax: lighten(color,amount[,options]) or darken(color,amount[,options]) or
+	 *         saturate(color,amount[,options]) or desaturate(color,amount[,options]) or
+	 *         fadein(color,amount[,options]) or fadeout(color,amount[,options])
 	 *   - color: a color (e.g. #f00) or a color function
 	 *   - amount: percentage 0-100%
-	 *   - options: [relative] [autoInverse] [lazy]
+	 *   - options: [relative] [autoInverse] [noAutoInverse] [lazy] [derived]
 	 */
-	private static Object parseColorLightenOrDarken( boolean lighten, List<String> params,
-		Function<String, String> resolver, boolean reportError )
+	private static Object parseColorHSLIncreaseDecrease( int hslIndex, boolean increase,
+		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" );
+
+			// use autoInverse by default for derived colors, except if noAutoInverse is set
+			if( derived && !options.contains( "noAutoInverse" ) )
+				autoInverse = true;
 		}
 
-		ColorFunctions.ColorFunction function = lighten
-			? new ColorFunctions.Lighten( amount, relative, autoInverse )
-			: new ColorFunctions.Darken( amount, relative, autoInverse );
-
-		if( isDerived )
-			return new DerivedColor( function );
+		// create function
+		ColorFunction function = new ColorFunctions.HSLIncreaseDecrease(
+			hslIndex, increase, amount, relative, autoInverse );
 
 		if( lazy ) {
 			return (LazyValue) t -> {
@@ -583,8 +710,146 @@ class UIDefaultsLoader
 			};
 		}
 
-		ColorUIResource color = (ColorUIResource) parseColorOrFunction( resolver.apply( colorStr ), resolver, reportError );
-		return new ColorUIResource( ColorFunctions.applyFunctions( color, function ) );
+		// parse base color, apply function and create derived color
+		return parseFunctionBaseColor( colorStr, function, derived, resolver, reportError );
+	}
+
+	/**
+	 * Syntax: fade(color,amount[,options])
+	 *   - color: a color (e.g. #f00) or a color function
+	 *   - amount: percentage 0-100%
+	 *   - options: [derived]
+	 */
+	private static Object parseColorFade( List<String> params, Function<String, String> resolver, boolean reportError ) {
+		String colorStr = params.get( 0 );
+		int amount = parsePercentage( params.get( 1 ) );
+		boolean derived = false;
+
+		if( params.size() > 2 ) {
+			String options = params.get( 2 );
+			derived = options.contains( "derived" );
+		}
+
+		// create function
+		ColorFunction function = new ColorFunctions.Fade( amount );
+
+		// parse base color, apply function and create derived color
+		return parseFunctionBaseColor( colorStr, function, derived, resolver, reportError );
+	}
+
+	/**
+	 * Syntax: spin(color,angle[,options])
+	 *   - color: a color (e.g. #f00) or a color function
+	 *   - angle: number of degrees to rotate
+	 *   - options: [derived]
+	 */
+	private static Object parseColorSpin( List<String> params, Function<String, String> resolver, boolean reportError ) {
+		String colorStr = params.get( 0 );
+		int amount = parseInteger( params.get( 1 ), true );
+		boolean derived = false;
+
+		if( params.size() > 2 ) {
+			String options = params.get( 2 );
+			derived = options.contains( "derived" );
+		}
+
+		// create function
+		ColorFunction function = new ColorFunctions.HSLIncreaseDecrease( 0, true, amount, false, false );
+
+		// parse base color, apply function and create derived color
+		return parseFunctionBaseColor( colorStr, function, derived, resolver, reportError );
+	}
+
+	/**
+	 * Syntax: changeHue(color,value[,options]) or
+	 *         changeSaturation(color,value[,options]) or
+	 *         changeLightness(color,value[,options]) or
+	 *         changeAlpha(color,value[,options])
+	 *   - color: a color (e.g. #f00) or a color function
+	 *   - value: for hue: number of degrees; otherwise: percentage 0-100%
+	 *   - options: [derived]
+	 */
+	private static Object parseColorChange( int hslIndex,
+		List<String> params, Function<String, String> resolver, boolean reportError )
+	{
+		String colorStr = params.get( 0 );
+		int value = (hslIndex == 0)
+			? parseInteger( params.get( 1 ), true )
+			: parsePercentage( params.get( 1 ) );
+		boolean derived = false;
+
+		if( params.size() > 2 ) {
+			String options = params.get( 2 );
+			derived = options.contains( "derived" );
+		}
+
+		// create function
+		ColorFunction function = new ColorFunctions.HSLChange( hslIndex, value );
+
+		// parse base color, apply function and create derived color
+		return parseFunctionBaseColor( colorStr, function, derived, resolver, reportError );
+	}
+
+	/**
+	 * Syntax: mix(color1,color2[,weight]) or
+	 *         tint(color[,weight]) or
+	 *         shade(color[,weight])
+	 *   - color1: a color (e.g. #f00) or a color function
+	 *   - color2: a color (e.g. #f00) or a color function
+	 *   - weight: the weight (in range 0-100%) to mix the two colors
+	 *             larger weight uses more of first color, smaller weight more of second color
+	 */
+	private static Object parseColorMix( String color1Str, List<String> params, Function<String, String> resolver, boolean reportError ) {
+		int i = 0;
+		if( color1Str == null )
+			color1Str = params.get( i++ );
+		String color2Str = params.get( i++ );
+		int weight = 50;
+
+		if( params.size() > i )
+			weight = parsePercentage( params.get( i++ ) );
+
+		// parse second color
+		String resolvedColor2Str = resolver.apply( color2Str );
+		ColorUIResource color2 = (ColorUIResource) parseColorOrFunction( resolvedColor2Str, resolver, reportError );
+		if( color2 == null )
+			return null;
+
+		// create function
+		ColorFunction function = new ColorFunctions.Mix( color2, weight );
+
+		// parse first color, apply function and create mixed color
+		return parseFunctionBaseColor( color1Str, function, false, resolver, reportError );
+	}
+
+	private static Object parseFunctionBaseColor( String colorStr, ColorFunction function,
+		boolean derived, Function<String, String> resolver, boolean reportError )
+	{
+		// parse base color
+		String resolvedColorStr = resolver.apply( colorStr );
+		ColorUIResource baseColor = (ColorUIResource) parseColorOrFunction( resolvedColorStr, resolver, reportError );
+		if( baseColor == null )
+			return null;
+
+		// apply this function to base color
+		Color newColor = ColorFunctions.applyFunctions( baseColor, function );
+
+		if( derived ) {
+			ColorFunction[] functions;
+			if( baseColor instanceof DerivedColor && resolvedColorStr == colorStr ) {
+				// if the base color is also derived, join the color functions
+				// but only if base color function is specified directly in this function
+				ColorFunction[] baseFunctions = ((DerivedColor)baseColor).getFunctions();
+				functions = new ColorFunction[baseFunctions.length + 1];
+				System.arraycopy( baseFunctions, 0, functions, 0, baseFunctions.length );
+				functions[baseFunctions.length] = function;
+			} else
+				functions = new ColorFunction[] { function };
+
+			return new DerivedColor( newColor, functions );
+		}
+
+		return new ColorUIResource( newColor );
 	}
 
 	private static int parsePercentage( String value ) {
@@ -609,7 +874,12 @@ class UIDefaultsLoader
 		return value.charAt( 0 );
 	}
 
-	private static Integer parseInteger( String value, int min, int max ) {
+	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 + ')' );
@@ -664,6 +934,21 @@ class UIDefaultsLoader
 		};
 	}
 
+	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.
 	 */
@@ -716,7 +1001,7 @@ class UIDefaultsLoader
 
 		Object value = UIManager.get( uiKey );
 		if( value == null && !optional )
-			FlatLaf.LOG.log( Level.SEVERE, "FlatLaf: '" + uiKey + "' not found in UI defaults." );
+			LoggingFacade.INSTANCE.logSevere( "FlatLaf: '" + uiKey + "' not found in UI defaults.", null );
 		return value;
 	}
 }

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.icons;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import com.formdev.flatlaf.util.AnimatedIcon;
+
+/**
+ * Base class for animated icons that scales width and height, creates and initializes
+ * a scaled graphics context for icon painting.
+ * <p>
+ * Subclasses do not need to scale icon painting.
+ * <p>
+ * This class does not store any state information (needed for animation) in its instance.
+ * Instead a client property is set on the painted component.
+ * This makes it possible to use a share icon instance for multiple components.
+ *
+ * @author Karl Tauber
+ */
+public abstract class FlatAnimatedIcon
+	extends FlatAbstractIcon
+	implements AnimatedIcon
+{
+	public FlatAnimatedIcon( int width, int height, Color color ) {
+		super( width, height, color );
+	}
+
+	@Override
+	public void paintIcon( Component c, Graphics g, int x, int y ) {
+		super.paintIcon( c, g, x, y );
+		AnimatedIcon.AnimationSupport.saveIconLocation( this, c, x, y );
+	}
+
+	@Override
+	protected void paintIcon( Component c, Graphics2D g ) {
+		AnimatedIcon.AnimationSupport.paintIcon( this, c, g, 0, 0 );
+	}
+}

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

@@ -27,7 +27,7 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 /**
  * "ascendingSort" icon for {@link javax.swing.table.JTableHeader}.
  *
- * @uiDefault Component.arrowType				String	triangle (default) or chevron
+ * @uiDefault Component.arrowType				String	chevron (default) or triangle
  * @uiDefault Table.sortIconColor				Color
  *
  * @author Karl Tauber
@@ -35,7 +35,7 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatAscendingSortIcon
 	extends FlatAbstractIcon
 {
-	protected final boolean chevron = "chevron".equals( UIManager.getString( "Component.arrowType" ) );
+	protected final boolean chevron = FlatUIUtils.isChevron( UIManager.getString( "Component.arrowType" ) );
 	protected final Color sortIconColor = UIManager.getColor( "Table.sortIconColor" );
 
 	public FlatAscendingSortIcon() {

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

@@ -44,7 +44,7 @@ public class FlatCapsLockIcon
 			<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"/>
+			    <rect width="6" height="2" x="5" y="11.5" fill="#FFF"/>
     			<path fill="#FFF" d="M2,8 L8,2 L14,8 L11,8 L11,10 L5,10 L5,8 L2,8 Z"/>
 			  </g>
 			</svg>
@@ -52,7 +52,7 @@ public class FlatCapsLockIcon
 
 		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( new Rectangle2D.Float( 5, 11.5f, 6, 2 ), false );
 		path.append( FlatUIUtils.createPath( 2,8, 8,2, 14,8, 11,8, 11,10, 5,10, 5,8 ), false );
 		g.fill( path );
 	}

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

@@ -36,25 +36,29 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
  *       is painted outside of the icon bounds. Make sure that the checkbox
  *       has margins, which are equal or greater than focusWidth.
  *
+ * @uiDefault CheckBox.icon.style						String	optional; "outline"/null (default) or "filled"
  * @uiDefault Component.focusWidth						int
  * @uiDefault Component.focusColor						Color
- * @uiDefault CheckBox.icon.focusedColor				Color	optional; defaults to Component.focusColor
+ * @uiDefault CheckBox.icon.focusWidth					int		optional; defaults to Component.focusWidth
+ * @uiDefault CheckBox.icon.focusColor					Color	optional; defaults to Component.focusColor
  * @uiDefault CheckBox.icon.borderColor					Color
- * @uiDefault CheckBox.icon.disabledBorderColor			Color
- * @uiDefault CheckBox.icon.selectedBorderColor			Color
- * @uiDefault CheckBox.icon.focusedBorderColor			Color
- * @uiDefault CheckBox.icon.hoverBorderColor			Color	optional
- * @uiDefault CheckBox.icon.selectedFocusedBorderColor	Color	optional
  * @uiDefault CheckBox.icon.background					Color
- * @uiDefault CheckBox.icon.disabledBackground			Color
- * @uiDefault CheckBox.icon.focusedBackground			Color	optional
- * @uiDefault CheckBox.icon.hoverBackground				Color	optional
- * @uiDefault CheckBox.icon.pressedBackground			Color	optional
+ * @uiDefault CheckBox.icon.selectedBorderColor			Color
  * @uiDefault CheckBox.icon.selectedBackground			Color
- * @uiDefault CheckBox.icon.selectedHoverBackground		Color	optional
- * @uiDefault CheckBox.icon.selectedPressedBackground	Color	optional
  * @uiDefault CheckBox.icon.checkmarkColor				Color
+ * @uiDefault CheckBox.icon.disabledBorderColor			Color
+ * @uiDefault CheckBox.icon.disabledBackground			Color
  * @uiDefault CheckBox.icon.disabledCheckmarkColor		Color
+ * @uiDefault CheckBox.icon.focusedBorderColor			Color	optional
+ * @uiDefault CheckBox.icon.focusedBackground			Color	optional
+ * @uiDefault CheckBox.icon.selectedFocusedBorderColor	Color	optional; CheckBox.icon.focusedBorderColor is used if not specified
+ * @uiDefault CheckBox.icon.selectedFocusedBackground	Color	optional; CheckBox.icon.focusedBackground is used if not specified
+ * @uiDefault CheckBox.icon.selectedFocusedCheckmarkColor	Color	optional; CheckBox.icon.checkmarkColor is used if not specified
+ * @uiDefault CheckBox.icon.hoverBorderColor			Color	optional
+ * @uiDefault CheckBox.icon.hoverBackground				Color	optional
+ * @uiDefault CheckBox.icon.selectedHoverBackground		Color	optional; CheckBox.icon.hoverBackground is used if not specified
+ * @uiDefault CheckBox.icon.pressedBackground			Color	optional
+ * @uiDefault CheckBox.icon.selectedPressedBackground	Color	optional; CheckBox.icon.pressedBackground is used if not specified
  * @uiDefault CheckBox.arc								int
  *
  * @author Karl Tauber
@@ -62,27 +66,62 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatCheckBoxIcon
 	extends FlatAbstractIcon
 {
-	public final int focusWidth = UIManager.getInt( "Component.focusWidth" );
-	protected final Color focusColor = FlatUIUtils.getUIColor( "CheckBox.icon.focusedColor",
+	protected final String style = UIManager.getString( "CheckBox.icon.style" );
+	public final int focusWidth = getUIInt( "CheckBox.icon.focusWidth",
+		UIManager.getInt( "Component.focusWidth" ), style );
+	protected final Color focusColor = FlatUIUtils.getUIColor( "CheckBox.icon.focusColor",
 		UIManager.getColor( "Component.focusColor" ) );
 	protected final int arc = FlatUIUtils.getUIInt( "CheckBox.arc", 2 );
 
-	protected final Color borderColor = UIManager.getColor( "CheckBox.icon.borderColor" );
-	protected final Color disabledBorderColor = UIManager.getColor( "CheckBox.icon.disabledBorderColor" );
-	protected final Color selectedBorderColor = UIManager.getColor( "CheckBox.icon.selectedBorderColor" );
-	protected final Color focusedBorderColor = UIManager.getColor( "CheckBox.icon.focusedBorderColor" );
-	protected final Color hoverBorderColor = UIManager.getColor( "CheckBox.icon.hoverBorderColor" );
-	protected final Color selectedFocusedBorderColor = UIManager.getColor( "CheckBox.icon.selectedFocusedBorderColor" );
-	protected final Color background = UIManager.getColor( "CheckBox.icon.background" );
-	protected final Color disabledBackground = UIManager.getColor( "CheckBox.icon.disabledBackground" );
-	protected final Color focusedBackground = UIManager.getColor( "CheckBox.icon.focusedBackground" );
-	protected final Color hoverBackground = UIManager.getColor( "CheckBox.icon.hoverBackground" );
-	protected final Color pressedBackground = UIManager.getColor( "CheckBox.icon.pressedBackground" );
-	protected final Color selectedBackground = UIManager.getColor( "CheckBox.icon.selectedBackground" );
-	protected final Color selectedHoverBackground = UIManager.getColor( "CheckBox.icon.selectedHoverBackground" );
-	protected final Color selectedPressedBackground = UIManager.getColor( "CheckBox.icon.selectedPressedBackground" );
-	protected final Color checkmarkColor = UIManager.getColor( "CheckBox.icon.checkmarkColor" );
-	protected final Color disabledCheckmarkColor = UIManager.getColor( "CheckBox.icon.disabledCheckmarkColor" );
+	// enabled
+	protected final Color borderColor = getUIColor( "CheckBox.icon.borderColor", style );
+	protected final Color background = getUIColor( "CheckBox.icon.background", style );
+	protected final Color selectedBorderColor = getUIColor( "CheckBox.icon.selectedBorderColor", style );
+	protected final Color selectedBackground = getUIColor( "CheckBox.icon.selectedBackground", style );
+	protected final Color checkmarkColor = getUIColor( "CheckBox.icon.checkmarkColor", style );
+
+	// disabled
+	protected final Color disabledBorderColor = getUIColor( "CheckBox.icon.disabledBorderColor", style );
+	protected final Color disabledBackground = getUIColor( "CheckBox.icon.disabledBackground", style );
+	protected final Color disabledCheckmarkColor = getUIColor( "CheckBox.icon.disabledCheckmarkColor", style );
+
+	// focused
+	protected final Color focusedBorderColor = getUIColor( "CheckBox.icon.focusedBorderColor", style );
+	protected final Color focusedBackground = getUIColor( "CheckBox.icon.focusedBackground", style );
+	protected final Color selectedFocusedBorderColor = getUIColor( "CheckBox.icon.selectedFocusedBorderColor", style );
+	protected final Color selectedFocusedBackground = getUIColor( "CheckBox.icon.selectedFocusedBackground", style );
+	protected final Color selectedFocusedCheckmarkColor = getUIColor( "CheckBox.icon.selectedFocusedCheckmarkColor", style );
+
+	// hover
+	protected final Color hoverBorderColor = getUIColor( "CheckBox.icon.hoverBorderColor", style );
+	protected final Color hoverBackground = getUIColor( "CheckBox.icon.hoverBackground", style );
+	protected final Color selectedHoverBackground = getUIColor( "CheckBox.icon.selectedHoverBackground", style );
+
+	// pressed
+	protected final Color pressedBackground = getUIColor( "CheckBox.icon.pressedBackground", style );
+	protected final Color selectedPressedBackground = getUIColor( "CheckBox.icon.selectedPressedBackground", style );
+
+	protected static Color getUIColor( String key, String style ) {
+		if( style != null ) {
+			Color color = UIManager.getColor( styleKey( key, style ) );
+			if( color != null )
+				return color;
+		}
+		return UIManager.getColor( key );
+	}
+
+	protected static int getUIInt( String key, int defaultValue, String style ) {
+		if( style != null ) {
+			Object value = UIManager.get( styleKey( key, style ) );
+			if( value instanceof Integer )
+				return (Integer) value;
+		}
+		return FlatUIUtils.getUIInt( key, defaultValue );
+	}
+
+	private static String styleKey( String key, String style ) {
+		return key.replace( ".icon.", ".icon[" + style + "]." );
+	}
 
 	static final int ICON_SIZE = 15;
 
@@ -91,73 +130,108 @@ public class FlatCheckBoxIcon
 	}
 
 	@Override
-	protected void paintIcon( Component c, Graphics2D g2 ) {
-		boolean indeterminate = c instanceof JComponent && clientPropertyEquals( (JComponent) c, SELECTED_STATE, SELECTED_STATE_INDETERMINATE );
-		boolean selected = indeterminate || (c instanceof AbstractButton && ((AbstractButton)c).isSelected());
+	protected void paintIcon( Component c, Graphics2D g ) {
+		boolean indeterminate = isIndeterminate( c );
+		boolean selected = indeterminate || isSelected( c );
+		boolean isFocused = FlatUIUtils.isPermanentFocusOwner( c );
 
 		// paint focused border
-		if( c.hasFocus() && focusWidth > 0 ) {
-			g2.setColor( focusColor );
-			paintFocusBorder( g2 );
+		if( isFocused && focusWidth > 0 && FlatButtonUI.isFocusPainted( c ) ) {
+			g.setColor( getFocusColor( c ) );
+			paintFocusBorder( c, g );
 		}
 
 		// paint border
-		g2.setColor( FlatButtonUI.buttonStateColor( c,
-			selected ? selectedBorderColor : borderColor,
-			disabledBorderColor,
-			selected && selectedFocusedBorderColor != null ? selectedFocusedBorderColor : focusedBorderColor,
-			hoverBorderColor,
-			null ) );
-		paintBorder( g2 );
+		g.setColor( getBorderColor( c, selected ) );
+		paintBorder( c, g );
 
 		// paint background
-		FlatUIUtils.setColor( g2, FlatButtonUI.buttonStateColor( c,
-			selected ? selectedBackground : background,
-			disabledBackground,
-			focusedBackground,
-			selected && selectedHoverBackground != null ? selectedHoverBackground : hoverBackground,
-			selected && selectedPressedBackground != null ? selectedPressedBackground : pressedBackground ),
-			background );
-		paintBackground( g2 );
+		Color bg = FlatUIUtils.deriveColor( getBackground( c, selected ),
+			selected ? selectedBackground : background );
+		if( bg.getAlpha() < 255 ) {
+			// fill background with default color before filling with non-opaque background
+			g.setColor( selected ? selectedBackground : background );
+			paintBackground( c, g );
+		}
+		g.setColor( bg );
+		paintBackground( c, g );
 
 		// paint checkmark
 		if( selected || indeterminate ) {
-			g2.setColor( c.isEnabled() ? checkmarkColor : disabledCheckmarkColor );
+			g.setColor( getCheckmarkColor( c, selected, isFocused ) );
 			if( indeterminate )
-				paintIndeterminate( g2 );
+				paintIndeterminate( c, g );
 			else
-				paintCheckmark( g2 );
+				paintCheckmark( c, g );
 		}
 	}
 
-	protected void paintFocusBorder( Graphics2D g2 ) {
+	protected void paintFocusBorder( Component c, Graphics2D g ) {
 		// the outline focus border is painted outside of the icon
 		int wh = ICON_SIZE - 1 + (focusWidth * 2);
 		int arcwh = arc + (focusWidth * 2);
-		g2.fillRoundRect( -focusWidth + 1, -focusWidth, wh, wh, arcwh, arcwh );
+		g.fillRoundRect( -focusWidth + 1, -focusWidth, wh, wh, arcwh, arcwh );
 	}
 
-	protected void paintBorder( Graphics2D g2 ) {
+	protected void paintBorder( Component c, Graphics2D g ) {
 		int arcwh = arc;
-		g2.fillRoundRect( 1, 0, 14, 14, arcwh, arcwh );
+		g.fillRoundRect( 1, 0, 14, 14, arcwh, arcwh );
 	}
 
-	protected void paintBackground( Graphics2D g2 ) {
+	protected void paintBackground( Component c, Graphics2D g ) {
 		int arcwh = arc - 1;
-		g2.fillRoundRect( 2, 1, 12, 12, arcwh, arcwh );
+		g.fillRoundRect( 2, 1, 12, 12, arcwh, arcwh );
 	}
 
-	protected void paintCheckmark( Graphics2D g2 ) {
+	protected void paintCheckmark( Component c, Graphics2D g ) {
 		Path2D.Float path = new Path2D.Float();
 		path.moveTo( 4.5f, 7.5f );
 		path.lineTo( 6.6f, 10f );
 		path.lineTo( 11.25f, 3.5f );
 
-		g2.setStroke( new BasicStroke( 1.9f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
-		g2.draw( path );
+		g.setStroke( new BasicStroke( 1.9f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND ) );
+		g.draw( path );
 	}
 
-	protected void paintIndeterminate( Graphics2D g2 ) {
-		g2.fill( new RoundRectangle2D.Float( 3.75f, 5.75f, 8.5f, 2.5f, 2f, 2f ) );
+	protected void paintIndeterminate( Component c, Graphics2D g ) {
+		g.fill( new RoundRectangle2D.Float( 3.75f, 5.75f, 8.5f, 2.5f, 2f, 2f ) );
+	}
+
+	protected boolean isIndeterminate( Component c ) {
+		return c instanceof JComponent && clientPropertyEquals( (JComponent) c, SELECTED_STATE, SELECTED_STATE_INDETERMINATE );
+	}
+
+	protected boolean isSelected( Component c ) {
+		return c instanceof AbstractButton && ((AbstractButton)c).isSelected();
+	}
+
+	protected Color getFocusColor( Component c ) {
+		return focusColor;
+	}
+
+	protected Color getBorderColor( Component c, boolean selected ) {
+		return FlatButtonUI.buttonStateColor( c,
+			selected ? selectedBorderColor : borderColor,
+			disabledBorderColor,
+			selected && selectedFocusedBorderColor != null ? selectedFocusedBorderColor : focusedBorderColor,
+			hoverBorderColor,
+			null );
+	}
+
+	protected Color getBackground( Component c, boolean selected ) {
+		return FlatButtonUI.buttonStateColor( c,
+			selected ? selectedBackground : background,
+			disabledBackground,
+			(selected && selectedFocusedBackground != null) ? selectedFocusedBackground : focusedBackground,
+			(selected && selectedHoverBackground != null) ? selectedHoverBackground : hoverBackground,
+			(selected && selectedPressedBackground != null) ? selectedPressedBackground : pressedBackground );
+	}
+
+	protected Color getCheckmarkColor( Component c, boolean selected, boolean isFocused ) {
+		return c.isEnabled()
+			? ((selected && isFocused && selectedFocusedCheckmarkColor != null)
+				? selectedFocusedCheckmarkColor
+				: checkmarkColor)
+			: disabledCheckmarkColor;
 	}
 }

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

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

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.icons;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Graphics2D;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Line2D;
+import java.awt.geom.Path2D;
+import javax.swing.AbstractButton;
+import javax.swing.ButtonModel;
+import javax.swing.UIManager;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+
+/**
+ * "clear" icon for search fields.
+ *
+ * @uiDefault SearchField.clearIconColor				Color
+ * @uiDefault SearchField.clearIconHoverColor			Color
+ * @uiDefault SearchField.clearIconPressedColor			Color
+ *
+ * @author Karl Tauber
+ * @since 1.5
+ */
+public class FlatClearIcon
+	extends FlatAbstractIcon
+{
+	protected Color clearIconColor = UIManager.getColor( "SearchField.clearIconColor" );
+	protected Color clearIconHoverColor = UIManager.getColor( "SearchField.clearIconHoverColor" );
+	protected Color clearIconPressedColor = UIManager.getColor( "SearchField.clearIconPressedColor" );
+
+	public FlatClearIcon() {
+		super( 16, 16, null );
+	}
+
+	@Override
+	protected void paintIcon( Component c, Graphics2D g ) {
+		if( c instanceof AbstractButton ) {
+			ButtonModel model = ((AbstractButton)c).getModel();
+			if( model.isPressed() || model.isRollover() ) {
+				/*
+					<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+					  <path fill="#7F8B91" fill-opacity=".5" fill-rule="evenodd" d="M8,1.75 C11.4517797,1.75 14.25,4.54822031 14.25,8 C14.25,11.4517797 11.4517797,14.25 8,14.25 C4.54822031,14.25 1.75,11.4517797 1.75,8 C1.75,4.54822031 4.54822031,1.75 8,1.75 Z M10.5,4.5 L8,7 L5.5,4.5 L4.5,5.5 L7,8 L4.5,10.5 L5.5,11.5 L8,9 L10.5,11.5 L11.5,10.5 L9,8 L11.5,5.5 L10.5,4.5 Z"/>
+					</svg>
+				*/
+
+				// paint filled circle with cross
+				g.setColor( model.isPressed() ? clearIconPressedColor : clearIconHoverColor );
+				Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
+				path.append( new Ellipse2D.Float( 1.75f, 1.75f, 12.5f, 12.5f ), false );
+				path.append( FlatUIUtils.createPath( 4.5,5.5, 5.5,4.5, 8,7,  10.5,4.5, 11.5,5.5, 9,8,  11.5,10.5, 10.5,11.5, 8,9,  5.5,11.5, 4.5,10.5, 7,8 ), false );
+				g.fill( path );
+				return;
+			}
+		}
+
+		/*
+			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+			  <path fill="none" stroke="#7F8B91" stroke-linecap="square" stroke-opacity=".5" d="M5,5 L11,11 M5,11 L11,5"/>
+			</svg>
+		*/
+
+		// paint cross
+		g.setColor( clearIconColor );
+		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
+		path.append( new Line2D.Float( 5,5, 11,11 ), false );
+		path.append( new Line2D.Float( 5,11, 11,5 ), false );
+		g.draw( path );
+	}
+}

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

@@ -27,7 +27,7 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 /**
  * "descendingSort" icon for {@link javax.swing.table.JTableHeader}.
  *
- * @uiDefault Component.arrowType				String	triangle (default) or chevron
+ * @uiDefault Component.arrowType				String	chevron (default) or triangle
  * @uiDefault Table.sortIconColor				Color
  *
  * @author Karl Tauber
@@ -35,7 +35,7 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatDescendingSortIcon
 	extends FlatAbstractIcon
 {
-	protected final boolean chevron = "chevron".equals( UIManager.getString( "Component.arrowType" ) );
+	protected final boolean chevron = FlatUIUtils.isChevron( UIManager.getString( "Component.arrowType" ) );
 	protected final Color sortIconColor = UIManager.getColor( "Table.sortIconColor" );
 
 	public FlatDescendingSortIcon() {

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

@@ -31,6 +31,8 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
  *
  * @uiDefault Component.focusWidth						int
  * @uiDefault Component.focusColor						Color
+ * @uiDefault HelpButton.innerFocusWidth				int or float	optional; defaults to Component.innerFocusWidth
+ * @uiDefault HelpButton.borderWidth					int		optional; default is 1
  * @uiDefault HelpButton.borderColor					Color
  * @uiDefault HelpButton.disabledBorderColor			Color
  * @uiDefault HelpButton.focusedBorderColor				Color
@@ -50,6 +52,8 @@ public class FlatHelpButtonIcon
 {
 	protected final int focusWidth = UIManager.getInt( "Component.focusWidth" );
 	protected final Color focusColor = UIManager.getColor( "Component.focusColor" );
+	protected final float innerFocusWidth = FlatUIUtils.getUIFloat( "HelpButton.innerFocusWidth", FlatUIUtils.getUIFloat( "Component.innerFocusWidth", 0 ) );
+	protected final int borderWidth = FlatUIUtils.getUIInt( "HelpButton.borderWidth", 1 );
 
 	protected final Color borderColor = UIManager.getColor( "HelpButton.borderColor" );
 	protected final Color disabledBorderColor = UIManager.getColor( "HelpButton.disabledBorderColor" );
@@ -82,14 +86,20 @@ public class FlatHelpButtonIcon
 		*/
 
 		boolean enabled = c.isEnabled();
-		boolean focused = c.hasFocus();
+		boolean focused = FlatUIUtils.isPermanentFocusOwner( c );
 
-		// paint focused border
-		if( focused ) {
+		float xy = 0.5f;
+		float wh = iconSize - 1;
+
+		// paint outer focus border
+		if( focused && FlatButtonUI.isFocusPainted( c ) ) {
 			g2.setColor( focusColor );
-			g2.fill( new Ellipse2D.Float( 0.5f, 0.5f, iconSize - 1, iconSize - 1 ) );
+			g2.fill( new Ellipse2D.Float( xy, xy, wh, wh ) );
 		}
 
+		xy += focusWidth;
+		wh -= (focusWidth * 2);
+
 		// paint border
 		g2.setColor( FlatButtonUI.buttonStateColor( c,
 			borderColor,
@@ -97,16 +107,28 @@ public class FlatHelpButtonIcon
 			focusedBorderColor,
 			hoverBorderColor,
 			null ) );
-		g2.fill( new Ellipse2D.Float( focusWidth + 0.5f, focusWidth + 0.5f, 21, 21 ) );
+		g2.fill( new Ellipse2D.Float( xy, xy, wh, wh ) );
+
+		xy += borderWidth;
+		wh -= (borderWidth * 2);
+
+		// paint inner focus border
+		if( innerFocusWidth > 0 && focused && FlatButtonUI.isFocusPainted( c ) ) {
+			g2.setColor( focusColor );
+			g2.fill( new Ellipse2D.Float( xy, xy, wh, wh ) );
+
+			xy += innerFocusWidth;
+			wh -= (innerFocusWidth * 2);
+		}
 
 		// paint background
-		FlatUIUtils.setColor( g2, FlatButtonUI.buttonStateColor( c,
+		g2.setColor( FlatUIUtils.deriveColor( FlatButtonUI.buttonStateColor( c,
 			background,
 			disabledBackground,
 			focusedBackground,
 			hoverBackground,
-			pressedBackground ), background );
-		g2.fill( new Ellipse2D.Float( focusWidth + 1.5f, focusWidth + 1.5f, 19, 19 ) );
+			pressedBackground ), background ) );
+		g2.fill( new Ellipse2D.Float( xy, xy, wh, wh ) );
 
 		// paint question mark
 		Path2D q = new Path2D.Float();

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

@@ -27,6 +27,7 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 /**
  * Base class for internal frame icons.
  *
+ * @uiDefault InternalFrame.buttonSize					Dimension
  * @uiDefault InternalFrame.buttonHoverBackground		Color
  * @uiDefault InternalFrame.buttonPressedBackground		Color
  *
@@ -53,7 +54,7 @@ public abstract class FlatInternalFrameAbstractIcon
 	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.setColor( FlatUIUtils.deriveColor( background, c.getBackground() ) );
 			g.fillRect( 0, 0, width, height );
 		}
 	}

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

@@ -28,8 +28,11 @@ import com.formdev.flatlaf.ui.FlatButtonUI;
 /**
  * "close" icon for {@link javax.swing.JInternalFrame}.
  *
- * @uiDefault InternalFrame.buttonHoverBackground		Color
- * @uiDefault InternalFrame.buttonPressedBackground		Color
+ * @uiDefault InternalFrame.buttonSize					Dimension
+ * @uiDefault InternalFrame.closeHoverBackground		Color
+ * @uiDefault InternalFrame.closePressedBackground		Color
+ * @uiDefault InternalFrame.closeHoverForeground		Color
+ * @uiDefault InternalFrame.closePressedForeground		Color
  *
  * @author Karl Tauber
  */

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

@@ -24,14 +24,14 @@ import java.awt.geom.Rectangle2D;
 import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
- * "minimize" (actually "restore") icon for {@link javax.swing.JInternalFrame}.
+ * "restore" (or "minimize") icon for {@link javax.swing.JInternalFrame}.
  *
  * @author Karl Tauber
  */
-public class FlatInternalFrameMinimizeIcon
+public class FlatInternalFrameRestoreIcon
 	extends FlatInternalFrameAbstractIcon
 {
-	public FlatInternalFrameMinimizeIcon() {
+	public FlatInternalFrameRestoreIcon() {
 	}
 
 	@Override

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

@@ -28,17 +28,18 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 /**
  * "arrow" icon for {@link javax.swing.JMenu}.
  *
- * @uiDefault Component.arrowType				String	triangle (default) or chevron
+ * @uiDefault Component.arrowType				String	chevron (default) or triangle
  * @uiDefault Menu.icon.arrowColor				Color
  * @uiDefault Menu.icon.disabledArrowColor		Color
  * @uiDefault Menu.selectionForeground			Color
+ * @uiDefault MenuItem.selectionType			String
  *
  * @author Karl Tauber
  */
 public class FlatMenuArrowIcon
 	extends FlatAbstractIcon
 {
-	protected final boolean chevron = "chevron".equals( UIManager.getString( "Component.arrowType" ) );
+	protected final boolean chevron = FlatUIUtils.isChevron( UIManager.getString( "Component.arrowType" ) );
 	protected final Color arrowColor = UIManager.getColor( "Menu.icon.arrowColor" );
 	protected final Color disabledArrowColor = UIManager.getColor( "Menu.icon.disabledArrowColor" );
 	protected final Color selectionForeground = UIManager.getColor( "Menu.selectionForeground" );
@@ -64,10 +65,15 @@ public class FlatMenuArrowIcon
 		}
 	}
 
-	private Color getArrowColor( Component c ) {
-		if( c instanceof JMenu && ((JMenu)c).isSelected() )
+	protected Color getArrowColor( Component c ) {
+		if( c instanceof JMenu && ((JMenu)c).isSelected() && !isUnderlineSelection() )
 			return selectionForeground;
 
 		return c.isEnabled() ? arrowColor : disabledArrowColor;
 	}
+
+	protected boolean isUnderlineSelection() {
+		// not storing value of "MenuItem.selectionType" in class to allow changing at runtime
+		return "underline".equals( UIManager.getString( "MenuItem.selectionType" ) );
+	}
 }

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

@@ -16,9 +16,9 @@
 
 package com.formdev.flatlaf.icons;
 
+import java.awt.Component;
 import java.awt.Graphics2D;
 import java.awt.geom.Ellipse2D;
-import com.formdev.flatlaf.ui.FlatUIUtils;
 
 /**
  * Icon for {@link javax.swing.JRadioButton}.
@@ -34,28 +34,28 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 public class FlatRadioButtonIcon
 	extends FlatCheckBoxIcon
 {
-	protected final int centerDiameter = FlatUIUtils.getUIInt( "RadioButton.icon.centerDiameter", 8 );
+	protected final int centerDiameter = getUIInt( "RadioButton.icon.centerDiameter", 8, style );
 
 	@Override
-	protected void paintFocusBorder( Graphics2D g2 ) {
+	protected void paintFocusBorder( Component c, Graphics2D g ) {
 		// the outline focus border is painted outside of the icon
 		int wh = ICON_SIZE + (focusWidth * 2);
-		g2.fillOval( -focusWidth, -focusWidth, wh, wh );
+		g.fillOval( -focusWidth, -focusWidth, wh, wh );
 	}
 
 	@Override
-	protected void paintBorder( Graphics2D g2 ) {
-		g2.fillOval( 0, 0, 15, 15 );
+	protected void paintBorder( Component c, Graphics2D g ) {
+		g.fillOval( 0, 0, 15, 15 );
 	}
 
 	@Override
-	protected void paintBackground( Graphics2D g2 ) {
-		g2.fillOval( 1, 1, 13, 13 );
+	protected void paintBackground( Component c, Graphics2D g ) {
+		g.fillOval( 1, 1, 13, 13 );
 	}
 
 	@Override
-	protected void paintCheckmark( Graphics2D g2 ) {
+	protected void paintCheckmark( Component c, Graphics2D g ) {
 		float xy = (ICON_SIZE - centerDiameter) / 2f;
-		g2.fill( new Ellipse2D.Float( xy, xy, centerDiameter, centerDiameter ) );
+		g.fill( new Ellipse2D.Float( xy, xy, centerDiameter, centerDiameter ) );
 	}
 }

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.icons;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Graphics2D;
+import java.awt.geom.Area;
+import java.awt.geom.Ellipse2D;
+import javax.swing.UIManager;
+import com.formdev.flatlaf.ui.FlatButtonUI;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+
+/**
+ * "search" icon for search fields.
+ *
+ * @uiDefault SearchField.searchIconColor				Color
+ * @uiDefault SearchField.searchIconHoverColor			Color
+ * @uiDefault SearchField.searchIconPressedColor		Color
+ *
+ * @author Karl Tauber
+ * @since 1.5
+ */
+public class FlatSearchIcon
+	extends FlatAbstractIcon
+{
+	protected Color searchIconColor = UIManager.getColor( "SearchField.searchIconColor" );
+	protected Color searchIconHoverColor = UIManager.getColor( "SearchField.searchIconHoverColor" );
+	protected Color searchIconPressedColor = UIManager.getColor( "SearchField.searchIconPressedColor" );
+
+	public FlatSearchIcon() {
+		super( 16, 16, null );
+	}
+
+	@Override
+	protected void paintIcon( Component c, Graphics2D g ) {
+		/*
+			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+			  <g fill="none" fill-opacity=".9" fill-rule="evenodd">
+			    <polygon fill="#7F8B91" points="10.813 9.75 14 12.938 12.938 14 9.75 10.813"/>
+			    <path fill="#7F8B91" d="M7,2 C9.76142375,2 12,4.23857625 12,7 C12,9.76142375 9.76142375,12 7,12 C4.23857625,12 2,9.76142375 2,7 C2,4.23857625 4.23857625,2 7,2 Z M7,3 C4.790861,3 3,4.790861 3,7 C3,9.209139 4.790861,11 7,11 C9.209139,11 11,9.209139 11,7 C11,4.790861 9.209139,3 7,3 Z"/>
+			  </g>
+			</svg>
+		*/
+
+		g.setColor( FlatButtonUI.buttonStateColor( c, searchIconColor, searchIconColor,
+			null, searchIconHoverColor, searchIconPressedColor ) );
+
+		// paint magnifier
+		Area area = new Area( new Ellipse2D.Float( 2, 2, 10, 10 ) );
+		area.subtract( new Area( new Ellipse2D.Float( 3, 3, 8, 8 ) ) );
+		area.add( new Area( FlatUIUtils.createPath( 10.813,9.75, 14,12.938, 12.938,14, 9.75,10.813 ) ) );
+		g.fill( area );
+	}
+}

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.icons;
+
+import java.awt.Component;
+import java.awt.Graphics2D;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+
+/**
+ * "search with history" icon for search fields.
+ *
+ * @author Karl Tauber
+ * @since 1.5
+ */
+public class FlatSearchWithHistoryIcon
+	extends FlatSearchIcon
+{
+	public FlatSearchWithHistoryIcon() {
+	}
+
+	@Override
+	protected void paintIcon( Component c, Graphics2D g ) {
+		/*
+			<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16">
+			  <g fill="none" fill-opacity=".9" fill-rule="evenodd">
+			    <polygon fill="#7F8B91" points="8.813 9.75 12 12.938 10.938 14 7.75 10.813"/>
+			    <path fill="#7F8B91" d="M5,2 C7.76142375,2 10,4.23857625 10,7 C10,9.76142375 7.76142375,12 5,12 C2.23857625,12 0,9.76142375 0,7 C0,4.23857625 2.23857625,2 5,2 Z M5,3 C2.790861,3 1,4.790861 1,7 C1,9.209139 2.790861,11 5,11 C7.209139,11 9,9.209139 9,7 C9,4.790861 7.209139,3 5,3 Z"/>
+			    <polygon fill="#7F8B91" points="11 7 16 7 13.5 10"/>
+			  </g>
+			</svg>
+		*/
+
+		// paint magnifier
+		g.translate( -2, 0 );
+		super.paintIcon( c, g );
+		g.translate( 2, 0 );
+
+		// paint history arrow
+		g.fill( FlatUIUtils.createPath( 11,7, 16,7, 13.5,10 ) );
+	}
+}

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

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.icons;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.Graphics2D;
+import java.awt.geom.Line2D;
+import java.awt.geom.Path2D;
+import javax.swing.UIManager;
+import com.formdev.flatlaf.ui.FlatButtonUI;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+
+/**
+ * "close" icon for closable tabs in {@link javax.swing.JTabbedPane}.
+ *
+ * @uiDefault TabbedPane.closeSize						Dimension
+ * @uiDefault TabbedPane.closeArc						int
+ * @uiDefault TabbedPane.closeCrossPlainSize			float
+ * @uiDefault TabbedPane.closeCrossFilledSize			float
+ * @uiDefault TabbedPane.closeCrossLineWidth			float
+ * @uiDefault TabbedPane.closeBackground				Color
+ * @uiDefault TabbedPane.closeForeground				Color
+ * @uiDefault TabbedPane.closeHoverBackground			Color
+ * @uiDefault TabbedPane.closeHoverForeground			Color
+ * @uiDefault TabbedPane.closePressedBackground			Color
+ * @uiDefault TabbedPane.closePressedForeground			Color
+ *
+ * @author Karl Tauber
+ */
+public class FlatTabbedPaneCloseIcon
+	extends FlatAbstractIcon
+{
+	protected final Dimension size = UIManager.getDimension( "TabbedPane.closeSize" );
+	protected final int arc = UIManager.getInt( "TabbedPane.closeArc" );
+	protected final float crossPlainSize = FlatUIUtils.getUIFloat( "TabbedPane.closeCrossPlainSize", 7.5f );
+	protected final float crossFilledSize = FlatUIUtils.getUIFloat( "TabbedPane.closeCrossFilledSize", crossPlainSize );
+	protected final float closeCrossLineWidth = FlatUIUtils.getUIFloat( "TabbedPane.closeCrossLineWidth", 1f );
+	protected final Color background = UIManager.getColor( "TabbedPane.closeBackground" );
+	protected final Color foreground = UIManager.getColor( "TabbedPane.closeForeground" );
+	protected final Color hoverBackground = UIManager.getColor( "TabbedPane.closeHoverBackground" );
+	protected final Color hoverForeground = UIManager.getColor( "TabbedPane.closeHoverForeground" );
+	protected final Color pressedBackground = UIManager.getColor( "TabbedPane.closePressedBackground" );
+	protected final Color pressedForeground = UIManager.getColor( "TabbedPane.closePressedForeground" );
+
+	public FlatTabbedPaneCloseIcon() {
+		super( 16, 16, null );
+	}
+
+	@Override
+	protected void paintIcon( Component c, Graphics2D g ) {
+		// paint background
+		Color bg = FlatButtonUI.buttonStateColor( c, background, null, null, hoverBackground, pressedBackground );
+		if( bg != null ) {
+			g.setColor( FlatUIUtils.deriveColor( bg, c.getBackground() ) );
+			g.fillRoundRect( (width - size.width) / 2, (height - size.height) / 2,
+				size.width, size.height, arc, arc );
+		}
+
+		// set cross color
+		Color fg = FlatButtonUI.buttonStateColor( c, foreground, null, null, hoverForeground, pressedForeground );
+		g.setColor( FlatUIUtils.deriveColor( fg, c.getForeground() ) );
+
+		float mx = width / 2;
+		float my = height / 2;
+		float r = ((bg != null) ? crossFilledSize : crossPlainSize) / 2;
+
+		// paint cross
+		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
+		path.append( new Line2D.Float( mx - r, my - r, mx + r, my + r ), false );
+		path.append( new Line2D.Float( mx - r, my + r, mx + r, my - r ), false );
+		g.setStroke( new BasicStroke( closeCrossLineWidth ) );
+		g.draw( path );
+	}
+}

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

@@ -25,7 +25,7 @@ import com.formdev.flatlaf.ui.FlatUIUtils;
 /**
  * "collapsed" icon for {@link javax.swing.JTree}.
  *
- * @uiDefault Component.arrowType				String	triangle (default) or chevron
+ * @uiDefault Component.arrowType				String	chevron (default) or triangle
  * @uiDefault Tree.icon.collapsedColor			Color
  *
  * @author Karl Tauber
@@ -41,7 +41,7 @@ public class FlatTreeCollapsedIcon
 
 	FlatTreeCollapsedIcon( Color color ) {
 		super( 11, 11, color );
-		chevron = "chevron".equals( UIManager.getString( "Component.arrowType" ) );
+		chevron = FlatUIUtils.isChevron( UIManager.getString( "Component.arrowType" ) );
 	}
 
 	@Override

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

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.icons;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.Graphics2D;
+import javax.swing.UIManager;
+import com.formdev.flatlaf.ui.FlatButtonUI;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+import com.formdev.flatlaf.util.HiDPIUtils;
+
+/**
+ * Base class for window icons.
+ *
+ * @uiDefault TitlePane.buttonSize						Dimension
+ * @uiDefault TitlePane.buttonHoverBackground			Color
+ * @uiDefault TitlePane.buttonPressedBackground			Color
+ *
+ * @author Karl Tauber
+ */
+public abstract class FlatWindowAbstractIcon
+	extends FlatAbstractIcon
+{
+	private final Color hoverBackground;
+	private final Color pressedBackground;
+
+	public FlatWindowAbstractIcon() {
+		this( UIManager.getDimension( "TitlePane.buttonSize" ),
+			UIManager.getColor( "TitlePane.buttonHoverBackground" ),
+			UIManager.getColor( "TitlePane.buttonPressedBackground" ) );
+	}
+
+	public FlatWindowAbstractIcon( Dimension size, Color hoverBackground, Color pressedBackground ) {
+		super( size.width, size.height, null );
+		this.hoverBackground = hoverBackground;
+		this.pressedBackground = pressedBackground;
+	}
+
+	@Override
+	protected void paintIcon( Component c, Graphics2D g ) {
+		paintBackground( c, g );
+
+		g.setColor( getForeground( c ) );
+		HiDPIUtils.paintAtScale1x( g, 0, 0, width, height, this::paintIconAt1x );
+	}
+
+	protected abstract void paintIconAt1x( Graphics2D g, int x, int y, int width, int height, double scaleFactor );
+
+	protected void paintBackground( Component c, Graphics2D g ) {
+		Color background = FlatButtonUI.buttonStateColor( c, null, null, null, hoverBackground, pressedBackground );
+		if( background != null ) {
+			g.setColor( FlatUIUtils.deriveColor( background, c.getBackground() ) );
+			g.fillRect( 0, 0, width, height );
+		}
+	}
+
+	protected Color getForeground( Component c ) {
+		return c.getForeground();
+	}
+}

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

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.icons;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Graphics2D;
+import java.awt.geom.Line2D;
+import java.awt.geom.Path2D;
+import javax.swing.UIManager;
+import com.formdev.flatlaf.ui.FlatButtonUI;
+
+/**
+ * "close" icon for windows (frames and dialogs).
+ *
+ * @uiDefault TitlePane.closeHoverBackground			Color
+ * @uiDefault TitlePane.closePressedBackground			Color
+ * @uiDefault TitlePane.closeHoverForeground			Color
+ * @uiDefault TitlePane.closePressedForeground			Color
+ *
+ * @author Karl Tauber
+ */
+public class FlatWindowCloseIcon
+	extends FlatWindowAbstractIcon
+{
+	private final Color hoverForeground = UIManager.getColor( "TitlePane.closeHoverForeground" );
+	private final Color pressedForeground = UIManager.getColor( "TitlePane.closePressedForeground" );
+
+	public FlatWindowCloseIcon() {
+		super( UIManager.getDimension( "TitlePane.buttonSize" ),
+			UIManager.getColor( "TitlePane.closeHoverBackground" ),
+			UIManager.getColor( "TitlePane.closePressedBackground" ) );
+	}
+
+	@Override
+	protected void paintIconAt1x( Graphics2D g, int x, int y, int width, int height, double scaleFactor ) {
+		int iwh = (int) (10 * scaleFactor);
+		int ix = x + ((width - iwh) / 2);
+		int iy = y + ((height - iwh) / 2);
+		int ix2 = ix + iwh - 1;
+		int iy2 = iy + iwh - 1;
+		int thickness = (int) scaleFactor;
+
+		Path2D path = new Path2D.Float( Path2D.WIND_EVEN_ODD );
+		path.append( new Line2D.Float( ix, iy, ix2, iy2 ), false );
+		path.append( new Line2D.Float( ix, iy2, ix2, iy ), false );
+		g.setStroke( new BasicStroke( thickness ) );
+		g.draw( path );
+	}
+
+	@Override
+	protected Color getForeground( Component c ) {
+		return FlatButtonUI.buttonStateColor( c, c.getForeground(), null, null, hoverForeground, pressedForeground );
+	}
+}

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

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.icons;
+
+import java.awt.Graphics2D;
+
+/**
+ * "iconify" icon for windows (frames and dialogs).
+ *
+ * @author Karl Tauber
+ */
+public class FlatWindowIconifyIcon
+	extends FlatWindowAbstractIcon
+{
+	public FlatWindowIconifyIcon() {
+	}
+
+	@Override
+	protected void paintIconAt1x( Graphics2D g, int x, int y, int width, int height, double scaleFactor ) {
+		int iw = (int) (10 * scaleFactor);
+		int ih = (int) scaleFactor;
+		int ix = x + ((width - iw) / 2);
+		int iy = y + ((height - ih) / 2);
+
+		g.fillRect( ix, iy, iw, ih );
+	}
+}

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.icons;
+
+import java.awt.Graphics2D;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+
+/**
+ * "maximize" icon for windows (frames and dialogs).
+ *
+ * @author Karl Tauber
+ */
+public class FlatWindowMaximizeIcon
+	extends FlatWindowAbstractIcon
+{
+	public FlatWindowMaximizeIcon() {
+	}
+
+	@Override
+	protected void paintIconAt1x( Graphics2D g, int x, int y, int width, int height, double scaleFactor ) {
+		int iwh = (int) (10 * scaleFactor);
+		int ix = x + ((width - iwh) / 2);
+		int iy = y + ((height - iwh) / 2);
+		int thickness = (int) scaleFactor;
+
+		g.fill( FlatUIUtils.createRectangle( ix, iy, iwh, iwh, thickness ) );
+	}
+}

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.icons;
+
+import java.awt.Graphics2D;
+import java.awt.geom.Area;
+import java.awt.geom.Path2D;
+import java.awt.geom.Rectangle2D;
+import com.formdev.flatlaf.ui.FlatUIUtils;
+
+/**
+ * "restore" icon for windows (frames and dialogs).
+ *
+ * @author Karl Tauber
+ */
+public class FlatWindowRestoreIcon
+	extends FlatWindowAbstractIcon
+{
+	public FlatWindowRestoreIcon() {
+	}
+
+	@Override
+	protected void paintIconAt1x( Graphics2D g, int x, int y, int width, int height, double scaleFactor ) {
+		int iwh = (int) (10 * scaleFactor);
+		int ix = x + ((width - iwh) / 2);
+		int iy = y + ((height - iwh) / 2);
+		int thickness = (int) scaleFactor;
+
+		int rwh = (int) (8 * scaleFactor);
+		int ro2 = iwh - rwh;
+
+		Path2D r1 = FlatUIUtils.createRectangle( ix + ro2, iy, rwh, rwh, thickness );
+		Path2D r2 = FlatUIUtils.createRectangle( ix, iy + ro2, rwh, rwh, thickness );
+
+		Area area = new Area( r1 );
+		area.subtract( new Area( new Rectangle2D.Float( ix, iy + ro2, rwh, rwh ) ) );
+		g.fill( area );
+
+		g.fill( r2 );
+	}
+}

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

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.resources;
+
+/**
+ * The only purpose of this file is to add a .class file to this package to make it non-empty.
+ * Otherwise the compiler outputs a warning because this package is opend in module-info.java.
+ * Also when using --patch-module (e.g. from an IDE), an error would occur for empty packages.
+ *
+ * @author Karl Tauber
+ */
+interface EmptyPackage
+{
+}

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

@@ -17,15 +17,14 @@
 package com.formdev.flatlaf.ui;
 
 import static com.formdev.flatlaf.util.UIScale.scale;
-import java.awt.BasicStroke;
 import java.awt.Color;
+import java.awt.Container;
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
-import java.awt.Shape;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
-import java.awt.geom.Path2D;
+import javax.swing.JComponent;
 import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicArrowButton;
 
@@ -40,33 +39,40 @@ public class FlatArrowButton
 {
 	public static final int DEFAULT_ARROW_WIDTH = 8;
 
-	private final boolean chevron;
-	private final Color foreground;
-	private final Color disabledForeground;
-	private final Color hoverForeground;
-	private final Color hoverBackground;
+	protected final boolean chevron;
+	protected final Color foreground;
+	protected final Color disabledForeground;
+	protected final Color hoverForeground;
+	protected final Color hoverBackground;
+	protected final Color pressedForeground;
+	protected final Color pressedBackground;
 
 	private int arrowWidth = DEFAULT_ARROW_WIDTH;
-	private int xOffset = 0;
-	private int yOffset = 0;
+	private float xOffset = 0;
+	private float yOffset = 0;
 
 	private boolean hover;
+	private boolean pressed;
 
 	public FlatArrowButton( int direction, String type, Color foreground, Color disabledForeground,
-		Color hoverForeground, Color hoverBackground )
+		Color hoverForeground, Color hoverBackground, Color pressedForeground, Color pressedBackground )
 	{
 		super( direction, Color.WHITE, Color.WHITE, Color.WHITE, Color.WHITE );
 
-		this.chevron = "chevron".equals( type );
+		this.chevron = FlatUIUtils.isChevron( type );
 		this.foreground = foreground;
 		this.disabledForeground = disabledForeground;
 		this.hoverForeground = hoverForeground;
 		this.hoverBackground = hoverBackground;
+		this.pressedForeground = pressedForeground;
+		this.pressedBackground = pressedBackground;
 
 		setOpaque( false );
 		setBorder( null );
 
-		if( hoverForeground != null || hoverBackground != null ) {
+		if( hoverForeground != null || hoverBackground != null ||
+			pressedForeground != null || pressedBackground != null )
+		{
 			addMouseListener( new MouseAdapter() {
 				@Override
 				public void mouseEntered( MouseEvent e ) {
@@ -79,6 +85,18 @@ public class FlatArrowButton
 					hover = false;
 					repaint();
 				}
+
+				@Override
+				public void mousePressed( MouseEvent e ) {
+					pressed = true;
+					repaint();
+				}
+
+				@Override
+				public void mouseReleased( MouseEvent e ) {
+					pressed = false;
+					repaint();
+				}
 			} );
 		}
 	}
@@ -95,22 +113,49 @@ public class FlatArrowButton
 		return hover;
 	}
 
-	public int getXOffset() {
+	protected boolean isPressed() {
+		return pressed;
+	}
+
+	public float getXOffset() {
 		return xOffset;
 	}
 
-	public void setXOffset( int xOffset ) {
+	public void setXOffset( float xOffset ) {
 		this.xOffset = xOffset;
 	}
 
-	public int getYOffset() {
+	public float getYOffset() {
 		return yOffset;
 	}
 
-	public void setYOffset( int yOffset ) {
+	public void setYOffset( float yOffset ) {
 		this.yOffset = yOffset;
 	}
 
+	protected Color deriveBackground( Color background ) {
+		return background;
+	}
+
+	protected Color deriveForeground( Color foreground ) {
+		return FlatUIUtils.deriveColor( foreground, this.foreground );
+	}
+
+	/**
+	 * Returns the color used to paint the arrow.
+	 *
+	 * @since 1.2
+	 */
+	protected Color getArrowColor() {
+		return isEnabled()
+			? (pressedForeground != null && isPressed()
+				? pressedForeground
+				: (hoverForeground != null && isHover()
+					? hoverForeground
+					: foreground))
+			: disabledForeground;
+	}
+
 	@Override
 	public Dimension getPreferredSize() {
 		return scale( super.getPreferredSize() );
@@ -123,58 +168,42 @@ public class FlatArrowButton
 
 	@Override
 	public void paint( Graphics g ) {
-		Graphics2D g2 = (Graphics2D)g;
-		FlatUIUtils.setRenderingHints( g2 );
+		Object[] oldRenderingHints = FlatUIUtils.setRenderingHints( g );
 
-		int width = getWidth();
-		int height = getHeight();
-		boolean enabled = isEnabled();
+		// paint hover or pressed background
+		if( isEnabled() ) {
+			Color background = (pressedBackground != null && isPressed())
+				? pressedBackground
+				: (hoverBackground != null && isHover()
+					? hoverBackground
+					: null);
 
-		// paint hover background
-		if( enabled && isHover() && hoverBackground != null ) {
-			g.setColor( hoverBackground );
-			g.fillRect( 0, 0, width, height );
+			if( background != null ) {
+				g.setColor( deriveBackground( background ) );
+				paintBackground( (Graphics2D) g );
+			}
 		}
 
-		int direction = getDirection();
-		boolean vert = (direction == NORTH || direction == SOUTH);
-
-		int w = scale( arrowWidth + (chevron ? 0 : 1) );
-		int h = scale( (arrowWidth / 2) + (chevron ? 0 : 1) );
-		int rw = vert ? w : h;
-		int rh = vert ? h : w;
-		int x = Math.round( (width - rw) / 2f + scale( (float) xOffset ) );
-		int y = Math.round( (height - rh) / 2f + scale( (float) yOffset ) );
-
-		// optimization for small chevron arrows (e.g. OneTouchButtons in SplitPane)
-		if( x + rw >= width && x > 0 )
-			x--;
-		if( y + rh >= height && y > 0 )
-			y--;
-
 		// paint arrow
-		g.setColor( enabled
-			? (isHover() && hoverForeground != null ? hoverForeground : foreground)
-			: disabledForeground );
-		g.translate( x, y );
-		Shape arrowShape = createArrowShape( direction, chevron, w, h );
-		if( chevron ) {
-			g2.setStroke( new BasicStroke( scale( 1f ) ) );
-			g2.draw( arrowShape );
-		} else {
-			// triangle
-			g2.fill( arrowShape );
-		}
-		g.translate( -x, -y );
+		g.setColor( deriveForeground( getArrowColor() ) );
+		paintArrow( (Graphics2D) g );
+
+		FlatUIUtils.resetRenderingHints( g, oldRenderingHints );
 	}
 
-	public static Shape createArrowShape( int direction, boolean chevron, float w, float h ) {
-		switch( direction ) {
-			case NORTH:	return FlatUIUtils.createPath( !chevron, 0,h, (w / 2f),0, w,h );
-			case SOUTH:	return FlatUIUtils.createPath( !chevron, 0,0, (w / 2f),h, w,0 );
-			case WEST:	return FlatUIUtils.createPath( !chevron, h,0, 0,(w / 2f), h,w );
-			case EAST:	return FlatUIUtils.createPath( !chevron, 0,0, h,(w / 2f), 0,w );
-			default:	return new Path2D.Float();
-		}
+	protected void paintBackground( Graphics2D g ) {
+		g.fillRect( 0, 0, getWidth(), getHeight() );
+	}
+
+	protected void paintArrow( Graphics2D g ) {
+		boolean vert = (direction == NORTH || direction == SOUTH);
+		int x = 0;
+
+		// move arrow for round borders
+		Container parent = getParent();
+		if( vert && parent instanceof JComponent && FlatUIUtils.hasRoundBorder( (JComponent) parent ) )
+			x -= scale( parent.getComponentOrientation().isLeftToRight() ? 1 : -1 );
+
+		FlatUIUtils.paintArrow( g, x, 0, getWidth(), getHeight(), getDirection(), chevron, arrowWidth, xOffset, yOffset );
 	}
 }

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

@@ -22,37 +22,40 @@ import java.awt.Component;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.Insets;
-import java.awt.KeyboardFocusManager;
 import java.awt.Paint;
 import javax.swing.JComboBox;
 import javax.swing.JComponent;
 import javax.swing.JScrollPane;
 import javax.swing.JSpinner;
-import javax.swing.JTable;
-import javax.swing.JTextField;
-import javax.swing.JTree;
 import javax.swing.JViewport;
-import javax.swing.SwingUtilities;
 import javax.swing.UIManager;
 import javax.swing.plaf.basic.BasicBorders;
-import javax.swing.text.JTextComponent;
+import com.formdev.flatlaf.FlatClientProperties;
+import com.formdev.flatlaf.util.DerivedColor;
 
 /**
  * Border for various components (e.g. {@link javax.swing.JTextField}).
  *
  * There is empty space around the component border, if Component.focusWidth is greater than zero,
- * which is used to paint focus border.
+ * which is used to paint outer focus border.
  *
- * Because there is empty space (if focus border is not painted),
+ * Because there is empty space (if outer focus border is not painted),
  * UI delegates that use this border (or subclasses) must invoke
  * {@link FlatUIUtils#paintParentBackground} to paint the empty space correctly.
  *
- * @uiDefault Component.focusWidth			int
- * @uiDefault Component.innerFocusWidth		int or float
- * @uiDefault Component.focusColor			Color
- * @uiDefault Component.borderColor			Color
- * @uiDefault Component.disabledBorderColor	Color
- * @uiDefault Component.focusedBorderColor	Color
+ * @uiDefault Component.focusWidth						int
+ * @uiDefault Component.innerFocusWidth					int or float
+ * @uiDefault Component.innerOutlineWidth				int or float
+ * @uiDefault Component.focusColor						Color
+ * @uiDefault Component.borderColor						Color
+ * @uiDefault Component.disabledBorderColor				Color
+ * @uiDefault Component.focusedBorderColor				Color
+ *
+ * @uiDefault Component.error.borderColor				Color
+ * @uiDefault Component.error.focusedBorderColor		Color
+ * @uiDefault Component.warning.borderColor				Color
+ * @uiDefault Component.warning.focusedBorderColor		Color
+ * @uiDefault Component.custom.borderColor				Color
  *
  * @author Karl Tauber
  */
@@ -61,37 +64,79 @@ public class FlatBorder
 {
 	protected final int focusWidth = UIManager.getInt( "Component.focusWidth" );
 	protected final float innerFocusWidth = FlatUIUtils.getUIFloat( "Component.innerFocusWidth", 0 );
+	protected final float innerOutlineWidth = FlatUIUtils.getUIFloat( "Component.innerOutlineWidth", 0 );
 	protected final Color focusColor = UIManager.getColor( "Component.focusColor" );
 	protected final Color borderColor = UIManager.getColor( "Component.borderColor" );
 	protected final Color disabledBorderColor = UIManager.getColor( "Component.disabledBorderColor" );
 	protected final Color focusedBorderColor = UIManager.getColor( "Component.focusedBorderColor" );
 
+	protected final Color errorBorderColor = UIManager.getColor( "Component.error.borderColor" );
+	protected final Color errorFocusedBorderColor = UIManager.getColor( "Component.error.focusedBorderColor" );
+	protected final Color warningBorderColor = UIManager.getColor( "Component.warning.borderColor" );
+	protected final Color warningFocusedBorderColor = UIManager.getColor( "Component.warning.focusedBorderColor" );
+	protected final Color customBorderColor = UIManager.getColor( "Component.custom.borderColor" );
+
 	@Override
 	public void paintBorder( Component c, Graphics g, int x, int y, int width, int height ) {
 		Graphics2D g2 = (Graphics2D) g.create();
 		try {
 			FlatUIUtils.setRenderingHints( g2 );
 
-			boolean isCellEditor = isTableCellEditor( c );
-			float focusWidth = isCellEditor ? 0 : getFocusWidth( c );
-			float borderWidth = getBorderWidth( c );
-			float arc = isCellEditor ? 0 : getArc( c );
+			float focusWidth = scale( (float) getFocusWidth( c ) );
+			float borderWidth = scale( (float) getBorderWidth( c ) );
+			float arc = scale( (float) getArc( c ) );
+			Color outlineColor = getOutlineColor( c );
 
-			if( isFocused( c ) ) {
-				float innerFocusWidth = !(c instanceof JScrollPane) ? this.innerFocusWidth : 0;
+			// paint outer border
+			if( outlineColor != null || isFocused( c ) ) {
+				float innerWidth = !isCellEditor( c ) && !(c instanceof JScrollPane)
+					? (outlineColor != null ? innerOutlineWidth : getInnerFocusWidth( c ))
+					: 0;
 
-				g2.setColor( getFocusColor( c ) );
-				FlatUIUtils.paintComponentOuterBorder( g2, x, y, width, height, focusWidth,
-					getLineWidth( c ) + scale( innerFocusWidth ), arc );
+				if( focusWidth > 0 || innerWidth > 0 ) {
+					g2.setColor( (outlineColor != null) ? outlineColor : getFocusColor( c ) );
+					FlatUIUtils.paintComponentOuterBorder( g2, x, y, width, height,
+						focusWidth, borderWidth + scale( innerWidth ), arc );
+				}
 			}
 
-			g2.setPaint( getBorderColor( c ) );
+			// paint border
+			g2.setPaint( (outlineColor != null) ? outlineColor : getBorderColor( c ) );
 			FlatUIUtils.paintComponentBorder( g2, x, y, width, height, focusWidth, borderWidth, arc );
 		} finally {
 			g2.dispose();
 		}
 	}
 
+	/**
+	 * Returns the outline color of the component border specified in client property
+	 * {@link FlatClientProperties#OUTLINE}.
+	 */
+	protected Color getOutlineColor( Component c ) {
+		if( !(c instanceof JComponent) )
+			return null;
+
+		Object outline = ((JComponent)c).getClientProperty( FlatClientProperties.OUTLINE );
+		if( outline instanceof String ) {
+			switch( (String) outline ) {
+				case FlatClientProperties.OUTLINE_ERROR:
+					return isFocused( c ) ? errorFocusedBorderColor : errorBorderColor;
+
+				case FlatClientProperties.OUTLINE_WARNING:
+					return isFocused( c ) ? warningFocusedBorderColor : warningBorderColor;
+			}
+		} else if( outline instanceof Color ) {
+			Color color = (Color) outline;
+			// use color functions to compute color for unfocused state
+			if( !isFocused( c ) && customBorderColor instanceof DerivedColor )
+				color = ((DerivedColor)customBorderColor).derive( color );
+			return color;
+		} else if( outline instanceof Color[] && ((Color[])outline).length >= 2 )
+			return ((Color[])outline)[isFocused( c ) ? 0 : 1];
+
+		return null;
+	}
+
 	protected Color getFocusColor( Component c ) {
 		return focusColor;
 	}
@@ -111,71 +156,87 @@ public class FlatBorder
 				return false;
 		}
 
-		return c.isEnabled() && (!(c instanceof JTextComponent) || ((JTextComponent)c).isEditable());
+		return c.isEnabled();
 	}
 
 	protected boolean isFocused( Component c ) {
-		if( c instanceof JScrollPane ) {
-			JViewport viewport = ((JScrollPane)c).getViewport();
-			Component view = (viewport != null) ? viewport.getView() : null;
-			if( view != null ) {
-				if( view.hasFocus() )
-					return true;
-
-				if( (view instanceof JTable && ((JTable)view).isEditing()) ||
-					(view instanceof JTree && ((JTree)view).isEditing()) )
-				{
-					Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
-					if( focusOwner != null )
-						return SwingUtilities.isDescendingFrom( focusOwner, view );
-				}
-			}
-			return false;
-		} else if( c instanceof JComboBox && ((JComboBox<?>)c).isEditable() ) {
-			Component editorComponent = ((JComboBox<?>)c).getEditor().getEditorComponent();
-			return (editorComponent != null) ? editorComponent.hasFocus() : false;
-		} else if( c instanceof JSpinner ) {
-			JComponent editor = ((JSpinner)c).getEditor();
-			if( editor instanceof JSpinner.DefaultEditor ) {
-				JTextField textField = ((JSpinner.DefaultEditor)editor).getTextField();
-				if( textField != null )
-					return textField.hasFocus();
-			}
-			return false;
-		} else
-			return c.hasFocus();
+		if( c instanceof JScrollPane )
+			return FlatScrollPaneUI.isPermanentFocusOwner( (JScrollPane) c );
+		else if( c instanceof JComboBox )
+			return FlatComboBoxUI.isPermanentFocusOwner( (JComboBox<?>) c );
+		else if( c instanceof JSpinner )
+			return FlatSpinnerUI.isPermanentFocusOwner( (JSpinner) c );
+		else
+			return FlatUIUtils.isPermanentFocusOwner( c );
 	}
 
-	protected boolean isTableCellEditor( Component c ) {
-		return FlatUIUtils.isTableCellEditor( c );
+	protected boolean isCellEditor( Component c ) {
+		return FlatUIUtils.isCellEditor( c );
 	}
 
 	@Override
 	public Insets getBorderInsets( Component c, Insets insets ) {
-		boolean isCellEditor = isTableCellEditor( c );
-		float ow = (isCellEditor ? 0 : getFocusWidth( c )) + getLineWidth( c );
+		float focusWidth = scale( (float) getFocusWidth( c ) );
+		int ow = Math.round( focusWidth + scale( (float) getLineWidth( c ) ) );
 
 		insets = super.getBorderInsets( c, insets );
-		insets.top = Math.round( scale( (float) insets.top ) + ow );
-		insets.left = Math.round( scale( (float) insets.left ) + ow );
-		insets.bottom = Math.round( scale( (float) insets.bottom ) + ow );
-		insets.right = Math.round( scale( (float) insets.right ) + ow );
+
+		insets.top = scale( insets.top ) + ow;
+		insets.left = scale( insets.left ) + ow;
+		insets.bottom = scale( insets.bottom ) + ow;
+		insets.right = scale( insets.right ) + ow;
+
+		if( isCellEditor( c ) ) {
+			// remove top and bottom insets if used as cell editor
+			insets.top = insets.bottom = 0;
+
+			// remove right/left insets to avoid that text is truncated (e.g. in file chooser)
+			if( c.getComponentOrientation().isLeftToRight() )
+				insets.right = 0;
+			else
+				insets.left = 0;
+		}
+
 		return insets;
 	}
 
-	protected float getFocusWidth( Component c ) {
-		return scale( (float) focusWidth );
+	/**
+	 * Returns the (unscaled) thickness of the outer focus border.
+	 */
+	protected int getFocusWidth( Component c ) {
+		if( isCellEditor( c ) )
+			return 0;
+
+		return focusWidth;
 	}
 
-	protected float getLineWidth( Component c ) {
-		return scale( 1f );
+	/**
+	 * Returns the (unscaled) thickness of the inner focus border.
+	 */
+	protected float getInnerFocusWidth( Component c ) {
+		return innerFocusWidth;
 	}
 
-	protected float getBorderWidth( Component c ) {
+	/**
+	 * Returns the (unscaled) line thickness used to compute the border insets.
+	 * This may be different to {@link #getBorderWidth}.
+	 */
+	protected int getLineWidth( Component c ) {
+		return 1;
+	}
+
+	/**
+	 * Returns the (unscaled) line thickness used to paint the border.
+	 * This may be different to {@link #getLineWidth}.
+	 */
+	protected int getBorderWidth( Component c ) {
 		return getLineWidth( c );
 	}
 
-	protected float getArc( Component c ) {
+	/**
+	 * Returns the (unscaled) arc diameter of the border.
+	 */
+	protected int getArc( Component c ) {
 		return 0;
 	}
 }

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

@@ -16,11 +16,11 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
 import java.awt.Color;
 import java.awt.Component;
 import java.awt.GradientPaint;
 import java.awt.Graphics;
+import java.awt.Graphics2D;
 import java.awt.Insets;
 import java.awt.Paint;
 import javax.swing.AbstractButton;
@@ -43,9 +43,13 @@ import com.formdev.flatlaf.util.UIScale;
  * @uiDefault Button.default.hoverBorderColor	Color	optional
  * @uiDefault Button.default.focusedBorderColor	Color
  * @uiDefault Button.default.focusColor			Color
+ * @uiDefault Button.toolbar.focusColor			Color	optional; defaults to Component.focusColor
+ * @uiDefault Button.borderWidth				int
  * @uiDefault Button.default.borderWidth		int
+ * @uiDefault Button.innerFocusWidth			int or float	optional; defaults to Component.innerFocusWidth
  * @uiDefault Button.toolbar.margin				Insets
  * @uiDefault Button.toolbar.spacingInsets		Insets
+ * @uiDefault Button.toolbar.focusWidth			int or float		optional; default is 1
  * @uiDefault Button.arc						int
  *
  * @author Karl Tauber
@@ -63,23 +67,65 @@ public class FlatButtonBorder
 	protected final Color defaultHoverBorderColor = UIManager.getColor( "Button.default.hoverBorderColor" );
 	protected final Color defaultFocusedBorderColor = UIManager.getColor( "Button.default.focusedBorderColor" );
 	protected final Color defaultFocusColor = UIManager.getColor( "Button.default.focusColor" );
+	/** @since 1.4 */
+	protected final Color toolbarFocusColor = UIManager.getColor( "Button.toolbar.focusColor" );
+	protected final int borderWidth = UIManager.getInt( "Button.borderWidth" );
 	protected final int defaultBorderWidth = UIManager.getInt( "Button.default.borderWidth" );
+	protected final float buttonInnerFocusWidth = FlatUIUtils.getUIFloat( "Button.innerFocusWidth", innerFocusWidth );
 	protected final Insets toolbarMargin = UIManager.getInsets( "Button.toolbar.margin" );
 	protected final Insets toolbarSpacingInsets = UIManager.getInsets( "Button.toolbar.spacingInsets" );
+	/** @since 1.4 */
+	protected final float toolbarFocusWidth = FlatUIUtils.getUIFloat( "Button.toolbar.focusWidth", 1.5f );
 	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.isToolBarButton( c ) &&
+			(!FlatButtonUI.isBorderlessButton( c ) || FlatUIUtils.isPermanentFocusOwner( c )) &&
 			!FlatButtonUI.isHelpButton( c ) &&
 			!FlatToggleButtonUI.isTabButton( c ) )
 		  super.paintBorder( c, g, x, y, width, height );
+		else if( FlatButtonUI.isToolBarButton( c ) && isFocused( c ) )
+			paintToolBarFocus( c, g, x, y, width, height );
+	}
+
+	/**
+	 * @since 1.4
+	 */
+	protected void paintToolBarFocus( Component c, Graphics g, int x, int y, int width, int height ) {
+		Graphics2D g2 = (Graphics2D) g.create();
+		try {
+			FlatUIUtils.setRenderingHints( g2 );
+
+			float focusWidth = UIScale.scale( toolbarFocusWidth );
+			float arc = UIScale.scale( (float) getArc( c ) );
+			Color outlineColor = getOutlineColor( c );
+
+			Insets spacing = UIScale.scale( toolbarSpacingInsets );
+			x += spacing.left;
+			y += spacing.top;
+			width -= spacing.left + spacing.right;
+			height -= spacing.top + spacing.bottom;
+
+			g2.setColor( (outlineColor != null) ? outlineColor : getFocusColor( c ) );
+			// not using paintComponentOuterBorder() here because its round edges look too "thick"
+			FlatUIUtils.paintComponentBorder( g2, x, y, width, height, 0, focusWidth, arc );
+		} finally {
+			g2.dispose();
+		}
 	}
 
 	@Override
 	protected Color getFocusColor( Component c ) {
-		return FlatButtonUI.isDefaultButton( c ) ? defaultFocusColor : super.getFocusColor( c );
+		return (toolbarFocusColor != null && FlatButtonUI.isToolBarButton( c ))
+			? toolbarFocusColor
+			: (FlatButtonUI.isDefaultButton( c ) ? defaultFocusColor : super.getFocusColor( c ));
+	}
+
+	@Override
+	protected boolean isFocused( Component c ) {
+		return FlatButtonUI.isFocusPainted( c ) && super.isFocused( c );
 	}
 
 	@Override
@@ -115,8 +161,8 @@ public class FlatButtonBorder
 		} 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 )
+			// use smaller left and right insets for icon-only or single-character buttons (so that they are square)
+			if( FlatButtonUI.isIconOnlyOrSingleCharacterButton( c ) && ((AbstractButton)c).getMargin() instanceof UIResource )
 				insets.left = insets.right = Math.min( insets.top, insets.bottom );
 		}
 
@@ -124,17 +170,29 @@ public class FlatButtonBorder
 	}
 
 	@Override
-	protected float getFocusWidth( Component c ) {
-		return FlatToggleButtonUI.isTabButton( c ) ? 0 : super.getFocusWidth(c );
+	protected int 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 );
+	protected float getInnerFocusWidth( Component c ) {
+		return buttonInnerFocusWidth;
 	}
 
 	@Override
-	protected float getArc( Component c ) {
-		return FlatButtonUI.isSquareButton( c ) ? 0 : scale( (float) arc );
+	protected int getBorderWidth( Component c ) {
+		return FlatButtonUI.isDefaultButton( c ) ? defaultBorderWidth : borderWidth;
+	}
+
+	@Override
+	protected int getArc( Component c ) {
+		if( isCellEditor( c ) )
+			return 0;
+
+		switch( FlatButtonUI.getButtonType( c ) ) {
+			case FlatButtonUI.TYPE_SQUARE: return 0;
+			case FlatButtonUI.TYPE_ROUND_RECT: return Short.MAX_VALUE;
+			default: return arc;
+		}
 	}
 }

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

@@ -30,6 +30,7 @@ import java.awt.Insets;
 import java.awt.Rectangle;
 import java.awt.geom.RoundRectangle2D;
 import java.beans.PropertyChangeEvent;
+import java.util.Objects;
 import javax.swing.AbstractButton;
 import javax.swing.ButtonModel;
 import javax.swing.Icon;
@@ -39,7 +40,6 @@ 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;
@@ -61,8 +61,6 @@ import com.formdev.flatlaf.util.UIScale;
  *
  * <!-- FlatButtonUI -->
  *
- * @uiDefault Component.focusWidth				int
- * @uiDefault Button.arc						int
  * @uiDefault Button.minimumWidth				int
  * @uiDefault Button.iconTextGap				int
  * @uiDefault Button.startBackground			Color	optional; if set, a gradient paint is used and Button.background is ignored
@@ -70,7 +68,11 @@ import com.formdev.flatlaf.util.UIScale;
  * @uiDefault Button.focusedBackground			Color	optional
  * @uiDefault Button.hoverBackground			Color	optional
  * @uiDefault Button.pressedBackground			Color	optional
+ * @uiDefault Button.selectedBackground			Color
+ * @uiDefault Button.selectedForeground			Color
+ * @uiDefault Button.disabledBackground			Color	optional
  * @uiDefault Button.disabledText				Color
+ * @uiDefault Button.disabledSelectedBackground	Color
  * @uiDefault Button.default.background			Color
  * @uiDefault Button.default.startBackground	Color	optional; if set, a gradient paint is used and Button.default.background is ignored
  * @uiDefault Button.default.endBackground		Color	optional; if set, a gradient paint is used
@@ -86,23 +88,29 @@ import com.formdev.flatlaf.util.UIScale;
  * @uiDefault Button.toolbar.spacingInsets		Insets
  * @uiDefault Button.toolbar.hoverBackground	Color
  * @uiDefault Button.toolbar.pressedBackground	Color
+ * @uiDefault Button.toolbar.selectedBackground	Color
  *
  * @author Karl Tauber
  */
 public class FlatButtonUI
 	extends BasicButtonUI
 {
-	protected int focusWidth;
-	protected int arc;
 	protected int minimumWidth;
 	protected int iconTextGap;
 
+	protected Color background;
+	protected Color foreground;
+
 	protected Color startBackground;
 	protected Color endBackground;
 	protected Color focusedBackground;
 	protected Color hoverBackground;
 	protected Color pressedBackground;
+	protected Color selectedBackground;
+	protected Color selectedForeground;
+	protected Color disabledBackground;
 	protected Color disabledText;
+	protected Color disabledSelectedBackground;
 
 	protected Color defaultBackground;
 	protected Color defaultEndBackground;
@@ -119,17 +127,15 @@ public class FlatButtonUI
 	protected Insets toolbarSpacingInsets;
 	protected Color toolbarHoverBackground;
 	protected Color toolbarPressedBackground;
+	protected Color toolbarSelectedBackground;
 
 	private Icon helpButtonIcon;
+	private Insets defaultMargin;
 
 	private boolean defaults_initialized = false;
 
-	private static ComponentUI instance;
-
 	public static ComponentUI createUI( JComponent c ) {
-		if( instance == null )
-			instance = new FlatButtonUI();
-		return instance;
+		return FlatUIUtils.createSharedUI( FlatButtonUI.class, FlatButtonUI::new );
 	}
 
 	@Override
@@ -139,17 +145,22 @@ public class FlatButtonUI
 		if( !defaults_initialized ) {
 			String prefix = getPropertyPrefix();
 
-			focusWidth = UIManager.getInt( "Component.focusWidth" );
-			arc = UIManager.getInt( "Button.arc" );
 			minimumWidth = UIManager.getInt( prefix + "minimumWidth" );
 			iconTextGap = FlatUIUtils.getUIInt( prefix + "iconTextGap", 4 );
 
+			background = UIManager.getColor( prefix + "background" );
+			foreground = UIManager.getColor( prefix + "foreground" );
+
 			startBackground = UIManager.getColor( prefix + "startBackground" );
 			endBackground = UIManager.getColor( prefix + "endBackground" );
 			focusedBackground = UIManager.getColor( prefix + "focusedBackground" );
 			hoverBackground = UIManager.getColor( prefix + "hoverBackground" );
 			pressedBackground = UIManager.getColor( prefix + "pressedBackground" );
+			selectedBackground = UIManager.getColor( prefix + "selectedBackground" );
+			selectedForeground = UIManager.getColor( prefix + "selectedForeground" );
+			disabledBackground = UIManager.getColor( prefix + "disabledBackground" );
 			disabledText = UIManager.getColor( prefix + "disabledText" );
+			disabledSelectedBackground = UIManager.getColor( prefix + "disabledSelectedBackground" );
 
 			if( UIManager.getBoolean( "Button.paintShadow" ) ) {
 				shadowWidth = FlatUIUtils.getUIInt( "Button.shadowWidth", 2 );
@@ -172,8 +183,10 @@ public class FlatButtonUI
 			toolbarSpacingInsets = UIManager.getInsets( "Button.toolbar.spacingInsets" );
 			toolbarHoverBackground = UIManager.getColor( prefix + "toolbar.hoverBackground" );
 			toolbarPressedBackground = UIManager.getColor( prefix + "toolbar.pressedBackground" );
+			toolbarSelectedBackground = UIManager.getColor( prefix + "toolbar.selectedBackground" );
 
 			helpButtonIcon = UIManager.getIcon( "HelpButton.icon" );
+			defaultMargin = UIManager.getInsets( prefix + "margin" );
 
 			defaults_initialized = true;
 		}
@@ -187,7 +200,7 @@ public class FlatButtonUI
 		LookAndFeel.installProperty( b, "opaque", false );
 		LookAndFeel.installProperty( b, "iconTextGap", scale( iconTextGap ) );
 
-		MigLayoutVisualPadding.install( b, getFocusWidth( b ) );
+		MigLayoutVisualPadding.install( b );
 	}
 
 	@Override
@@ -200,21 +213,21 @@ public class FlatButtonUI
 
 	@Override
 	protected BasicButtonListener createButtonListener( AbstractButton b ) {
-		return new BasicButtonListener( b ) {
-			@Override
-			public void propertyChange( PropertyChangeEvent e ) {
-				super.propertyChange( e );
-				FlatButtonUI.this.propertyChange( b, e );
-			}
-		};
+		return new FlatButtonListener( b );
 	}
 
 	protected void propertyChange( AbstractButton b, PropertyChangeEvent e ) {
 		switch( e.getPropertyName() ) {
+			case SQUARE_SIZE:
 			case MINIMUM_WIDTH:
 			case MINIMUM_HEIGHT:
 				b.revalidate();
 				break;
+
+			case BUTTON_TYPE:
+				b.revalidate();
+				b.repaint();
+				break;
 		}
 	}
 
@@ -222,22 +235,48 @@ public class FlatButtonUI
 		return !(c instanceof AbstractButton) || ((AbstractButton)c).isContentAreaFilled();
 	}
 
+	public static boolean isFocusPainted( Component c ) {
+		return !(c instanceof AbstractButton) || ((AbstractButton)c).isFocusPainted();
+	}
+
 	static boolean isDefaultButton( Component c ) {
 		return c instanceof JButton && ((JButton)c).isDefaultButton();
 	}
 
-	static boolean isIconOnlyButton( Component c ) {
+	/**
+	 * Returns true if the button has an icon but no text,
+	 * or it it does not have an icon and the text is either "..." or one character.
+	 */
+	static boolean isIconOnlyOrSingleCharacterButton( Component c ) {
 		if( !(c instanceof JButton) && !(c instanceof JToggleButton) )
 			return false;
 
 		Icon icon = ((AbstractButton)c).getIcon();
 		String text = ((AbstractButton)c).getText();
 		return (icon != null && (text == null || text.isEmpty())) ||
-			(icon == null && text != null && ("...".equals( text ) || text.length() == 1));
+			(icon == null && text != null &&
+			 ("...".equals( text ) ||
+			  text.length() == 1 ||
+			  (text.length() == 2 && Character.isSurrogatePair( text.charAt( 0 ), text.charAt( 1 ) ))));
 	}
 
-	static boolean isSquareButton( Component c ) {
-		return c instanceof AbstractButton && clientPropertyEquals( (AbstractButton) c, BUTTON_TYPE, BUTTON_TYPE_SQUARE );
+	static final int TYPE_OTHER = -1;
+	static final int TYPE_SQUARE = 0;
+	static final int TYPE_ROUND_RECT = 1;
+
+	static int getButtonType( Component c ) {
+		if( !(c instanceof AbstractButton) )
+			return TYPE_OTHER;
+
+		Object value = ((AbstractButton)c).getClientProperty( BUTTON_TYPE );
+		if( !(value instanceof String) )
+			return TYPE_OTHER;
+
+		switch( (String) value ) {
+			case BUTTON_TYPE_SQUARE:		return TYPE_SQUARE;
+			case BUTTON_TYPE_ROUND_RECT:	return TYPE_ROUND_RECT;
+			default:						return TYPE_OTHER;
+		}
 	}
 
 	static boolean isHelpButton( Component c ) {
@@ -245,7 +284,12 @@ public class FlatButtonUI
 	}
 
 	static boolean isToolBarButton( Component c ) {
-		return c.getParent() instanceof JToolBar;
+		return c.getParent() instanceof JToolBar ||
+			(c instanceof AbstractButton && clientPropertyEquals( (AbstractButton) c, BUTTON_TYPE, BUTTON_TYPE_TOOLBAR_BUTTON ));
+	}
+
+	static boolean isBorderlessButton( Component c ) {
+		return c instanceof AbstractButton && clientPropertyEquals( (AbstractButton) c, BUTTON_TYPE, BUTTON_TYPE_BORDERLESS );
 	}
 
 	@Override
@@ -267,54 +311,62 @@ public class FlatButtonUI
 
 	protected void paintBackground( Graphics g, JComponent c ) {
 		Color background = getBackground( c );
-		if( background != null ) {
-			Graphics2D g2 = (Graphics2D) g.create();
-			try {
-				FlatUIUtils.setRenderingHints( g2 );
+		if( background == null )
+			return;
 
-				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 );
+		Graphics2D g2 = (Graphics2D) g.create();
+		try {
+			FlatUIUtils.setRenderingHints( g2 );
 
-				int x = 0;
-				int y = 0;
-				int width = c.getWidth();
-				int height = c.getHeight();
+			boolean isToolBarButton = isToolBarButton( c );
+			float focusWidth = isToolBarButton ? 0 : FlatUIUtils.getBorderFocusWidth( c );
+			float arc = FlatUIUtils.getBorderArc( c );
 
-				if( isToolBarButton ) {
-					Insets spacing = UIScale.scale( toolbarSpacingInsets );
-					x += spacing.left;
-					y += spacing.top;
-					width -= spacing.left + spacing.right;
-					height -= spacing.top + spacing.bottom;
-				}
+			boolean def = isDefaultButton( c );
 
-				// paint shadow
-				Color shadowColor = def ? defaultShadowColor : this.shadowColor;
-				if( !isToolBarButton && shadowColor != null && shadowWidth > 0 && focusWidth > 0 && !c.hasFocus() && c.isEnabled() ) {
-					g2.setColor( shadowColor );
-					g2.fill( new RoundRectangle2D.Float( focusWidth, focusWidth + UIScale.scale( (float) shadowWidth ),
-						width - focusWidth * 2, height - focusWidth * 2, arc, arc ) );
-				}
+			int x = 0;
+			int y = 0;
+			int width = c.getWidth();
+			int height = c.getHeight();
 
-				// 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();
+			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( shadowColor != null && shadowWidth > 0 && focusWidth > 0 && c.isEnabled() &&
+				!isToolBarButton && !isBorderlessButton( c ) &&
+				!(isFocusPainted( c ) && FlatUIUtils.isPermanentFocusOwner( c )) )
+			{
+				g2.setColor( shadowColor );
+				g2.fill( new RoundRectangle2D.Float( focusWidth, focusWidth + UIScale.scale( (float) shadowWidth ),
+					width - focusWidth * 2, height - focusWidth * 2, arc, arc ) );
+			}
+
+			// paint background
+			Color startBg = def ? defaultBackground : startBackground;
+			Color endBg = def ? defaultEndBackground : endBackground;
+			if( background == startBg && endBg != null && !startBg.equals( endBg ) )
+				g2.setPaint( new GradientPaint( 0, 0, startBg, 0, height, endBg ) );
+			else
+				g2.setColor( FlatUIUtils.deriveColor( background, getBackgroundBase( c, def ) ) );
+
+			FlatUIUtils.paintComponentBackground( g2, x, y, width, height, focusWidth, arc );
+		} finally {
+			g2.dispose();
 		}
 	}
 
+	@Override
+	public void paint( Graphics g, JComponent c ) {
+		super.paint( FlatLabelUI.createGraphicsHTMLTextYCorrection( g, c ), c );
+	}
+
 	@Override
 	protected void paintText( Graphics g, AbstractButton b, Rectangle textRect, String text ) {
 		if( isHelpButton( b ) )
@@ -331,7 +383,7 @@ public class FlatButtonUI
 			}
 		}
 
-		paintText( g, b, textRect, text, b.isEnabled() ? getForeground( b ) : disabledText );
+		paintText( g, b, textRect, text, getForeground( b ) );
 	}
 
 	public static void paintText( Graphics g, AbstractButton b, Rectangle textRect, String text, Color foreground ) {
@@ -344,53 +396,93 @@ public class FlatButtonUI
 	}
 
 	protected Color getBackground( JComponent c ) {
-		if( !c.isEnabled() )
-			return null;
+		boolean toolBarButton = isToolBarButton( c ) || isBorderlessButton( c );
+
+		// selected state
+		if( ((AbstractButton)c).isSelected() ) {
+			// in toolbar use same background colors for disabled and enabled because
+			// we assume that toolbar icon is shown disabled
+			return buttonStateColor( c,
+				toolBarButton ? toolbarSelectedBackground : selectedBackground,
+				toolBarButton ? toolbarSelectedBackground : disabledSelectedBackground,
+				null,
+				null,
+				toolBarButton ? toolbarPressedBackground : pressedBackground );
+		}
 
 		// toolbar button
-		if( isToolBarButton( c ) ) {
-			ButtonModel model = ((AbstractButton)c).getModel();
-			if( model.isPressed() )
-				return toolbarPressedBackground;
-			if( model.isRollover() )
-				return toolbarHoverBackground;
-
-			// use background of toolbar
-			return c.getParent().getBackground();
+		if( toolBarButton ) {
+			Color bg = c.getBackground();
+			return buttonStateColor( c,
+				isCustomBackground( bg ) ? bg : null,
+				null,
+				null,
+				toolbarHoverBackground,
+				toolbarPressedBackground );
 		}
 
 		boolean def = isDefaultButton( c );
 		return buttonStateColor( c,
-			def ? defaultBackground : c.getBackground(),
-			null,
-			def ? defaultFocusedBackground : focusedBackground,
+			getBackgroundBase( c, def ),
+			disabledBackground,
+			isCustomBackground( c.getBackground() ) ? null : (def ? defaultFocusedBackground : focusedBackground),
 			def ? defaultHoverBackground : hoverBackground,
 			def ? defaultPressedBackground : pressedBackground );
 	}
 
+	protected Color getBackgroundBase( JComponent c, boolean def ) {
+		// use component background if explicitly set
+		Color bg = c.getBackground();
+		if( isCustomBackground( bg ) )
+			return bg;
+
+		return def ? defaultBackground : bg;
+	}
+
+	protected boolean isCustomBackground( Color bg ) {
+		return bg != background && (startBackground == null || bg != startBackground);
+	}
+
 	public static Color buttonStateColor( Component c, Color enabledColor, Color disabledColor,
 		Color focusedColor, Color hoverColor, Color pressedColor )
 	{
-		AbstractButton b = (c instanceof AbstractButton) ? (AbstractButton) c : null;
-
 		if( !c.isEnabled() )
 			return disabledColor;
 
-		if( pressedColor != null && b != null && b.getModel().isPressed() )
-			return pressedColor;
+		if( c instanceof AbstractButton ) {
+			ButtonModel model = ((AbstractButton)c).getModel();
 
-		if( hoverColor != null && b != null && b.getModel().isRollover() )
-			return hoverColor;
+			if( pressedColor != null && model.isPressed() )
+				return pressedColor;
 
-		if( focusedColor != null && c.hasFocus() )
+			if( hoverColor != null && model.isRollover() )
+				return hoverColor;
+		}
+
+		if( focusedColor != null && isFocusPainted( c ) && FlatUIUtils.isPermanentFocusOwner( c ) )
 			return focusedColor;
 
 		return enabledColor;
 	}
 
 	protected Color getForeground( JComponent c ) {
+		if( !c.isEnabled() )
+			return disabledText;
+
+		if( ((AbstractButton)c).isSelected() && !(isToolBarButton( c ) || isBorderlessButton( c )) )
+			return selectedForeground;
+
+		// use component foreground if explicitly set
+		Color fg = c.getForeground();
+		if( isCustomForeground( fg ) )
+			return fg;
+
 		boolean def = isDefaultButton( c );
-		return def ? defaultForeground : c.getForeground();
+		return def ? defaultForeground : fg;
+	}
+
+	protected boolean isCustomForeground( Color fg ) {
+		return fg != foreground;
 	}
 
 	@Override
@@ -399,23 +491,50 @@ public class FlatButtonUI
 			return new Dimension( helpButtonIcon.getIconWidth(), helpButtonIcon.getIconHeight() );
 
 		Dimension prefSize = super.getPreferredSize( c );
-		if ( prefSize == null )
+		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 ) )
+		// make square or apply minimum width/height
+		boolean isIconOnlyOrSingleCharacter = isIconOnlyOrSingleCharacterButton( c );
+		if( clientPropertyBoolean( c, SQUARE_SIZE, false ) ) {
+			// make button square (increase width or height so that they are equal)
+			prefSize.width = prefSize.height = Math.max( prefSize.width, prefSize.height );
+		} else if( isIconOnlyOrSingleCharacter && ((AbstractButton)c).getIcon() == null ) {
+			// make single-character-no-icon button square (increase width)
 			prefSize.width = Math.max( prefSize.width, prefSize.height );
-		else if( !isToolBarButton( c ) && 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) ) );
+		} else if( !isIconOnlyOrSingleCharacter && !isToolBarButton( c ) &&
+			c.getBorder() instanceof FlatButtonBorder && hasDefaultMargins( c ) )
+		{
+			// apply minimum width/height
+			int fw = Math.round( FlatUIUtils.getBorderFocusWidth( c ) * 2 );
+			prefSize.width = Math.max( prefSize.width, scale( FlatUIUtils.minimumWidth( c, minimumWidth ) ) + fw );
+			prefSize.height = Math.max( prefSize.height, scale( FlatUIUtils.minimumHeight( c, 0 ) ) + fw );
 		}
 
 		return prefSize;
 	}
 
-	protected int getFocusWidth( JComponent c ) {
-		return focusWidth;
+	private boolean hasDefaultMargins( JComponent c ) {
+		Insets margin = ((AbstractButton)c).getMargin();
+		return margin instanceof UIResource && Objects.equals( margin, defaultMargin );
+	}
+
+	//---- class FlatButtonListener -------------------------------------------
+
+	protected class FlatButtonListener
+		extends BasicButtonListener
+	{
+		private final AbstractButton b;
+
+		protected FlatButtonListener( AbstractButton b ) {
+			super( b );
+			this.b = b;
+		}
+
+		@Override
+		public void propertyChange( PropertyChangeEvent e ) {
+			super.propertyChange( e );
+			FlatButtonUI.this.propertyChange( b, e );
+		}
 	}
 }

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

@@ -18,10 +18,13 @@ package com.formdev.flatlaf.ui;
 
 import static com.formdev.flatlaf.FlatClientProperties.*;
 import java.awt.EventQueue;
+import java.awt.Insets;
+import java.awt.Rectangle;
 import java.awt.event.FocusEvent;
 import java.awt.event.MouseEvent;
 import javax.swing.JFormattedTextField;
 import javax.swing.plaf.UIResource;
+import javax.swing.text.BadLocationException;
 import javax.swing.text.DefaultCaret;
 import javax.swing.text.Document;
 import javax.swing.text.JTextComponent;
@@ -31,18 +34,20 @@ import javax.swing.text.JTextComponent;
  *
  * @author Karl Tauber
  */
-class FlatCaret
+public class FlatCaret
 	extends DefaultCaret
 	implements UIResource
 {
 	private final String selectAllOnFocusPolicy;
+	private final boolean selectAllOnMouseClick;
 
 	private boolean wasFocused;
 	private boolean wasTemporaryLost;
 	private boolean isMousePressed;
 
-	FlatCaret( String selectAllOnFocusPolicy ) {
+	public FlatCaret( String selectAllOnFocusPolicy, boolean selectAllOnMouseClick ) {
 		this.selectAllOnFocusPolicy = selectAllOnFocusPolicy;
+		this.selectAllOnMouseClick = selectAllOnMouseClick;
 	}
 
 	@Override
@@ -59,9 +64,22 @@ class FlatCaret
 		}
 	}
 
+	@Override
+	protected void adjustVisibility( Rectangle nloc ) {
+		JTextComponent c = getComponent();
+		if( c != null && c.getUI() instanceof FlatTextFieldUI ) {
+			Insets padding = ((FlatTextFieldUI)c.getUI()).getPadding();
+			if( padding != null ) {
+				nloc.x -= padding.left;
+				nloc.y -= padding.top;
+			}
+		}
+		super.adjustVisibility( nloc );
+	}
+
 	@Override
 	public void focusGained( FocusEvent e ) {
-		if( !wasTemporaryLost && !isMousePressed )
+		if( !wasTemporaryLost && (!isMousePressed || selectAllOnMouseClick) )
 			selectAllOnFocusGained();
 		wasTemporaryLost = false;
 		wasFocused = true;
@@ -87,10 +105,10 @@ class FlatCaret
 		super.mouseReleased( e );
 	}
 
-	private void selectAllOnFocusGained() {
+	protected void selectAllOnFocusGained() {
 		JTextComponent c = getComponent();
 		Document doc = c.getDocument();
-		if( doc == null || !c.isEnabled() || !c.isEditable() )
+		if( doc == null || !c.isEnabled() || !c.isEditable() || FlatUIUtils.isCellEditor( c ) )
 			return;
 
 		Object selectAllOnFocusPolicy = c.getClientProperty( SELECT_ALL_ON_FOCUS_POLICY );
@@ -125,4 +143,23 @@ class FlatCaret
 			moveDot( doc.getLength() );
 		}
 	}
+
+	/**
+	 * @since 1.4
+	 */
+	public void scrollCaretToVisible() {
+		JTextComponent c = getComponent();
+		if( c == null || c.getUI() == null )
+			return;
+
+		try {
+			Rectangle loc = c.getUI().modelToView( c, getDot(), getDotBias() );
+			if( loc != null ) {
+				adjustVisibility( loc );
+				damage( loc );
+			}
+		} catch( BadLocationException ex ) {
+			// ignore
+		}
+	}
 }

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

@@ -16,12 +16,11 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
+import java.awt.Dimension;
 import java.awt.Graphics;
-import java.awt.Rectangle;
-import java.beans.PropertyChangeListener;
+import javax.swing.Icon;
 import javax.swing.JComponent;
-import javax.swing.JMenuItem;
+import javax.swing.LookAndFeel;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicCheckBoxMenuItemUI;
 
@@ -30,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();
 	}
@@ -61,25 +65,30 @@ public class FlatCheckBoxMenuItemUI
 	protected void installDefaults() {
 		super.installDefaults();
 
-		// scale
-		defaultTextIconGap = scale( defaultTextIconGap );
-	}
+		LookAndFeel.installProperty( menuItem, "iconTextGap", FlatUIUtils.getUIInt( "MenuItem.iconTextGap", 4 ) );
 
-	/**
-	 * 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 );
-		};
+		renderer = createRenderer();
 	}
 
 	@Override
-	protected void paintText( Graphics g, JMenuItem menuItem, Rectangle textRect, String text ) {
-		FlatMenuItemUI.paintText( g, menuItem, textRect, text, disabledForeground, selectionForeground );
+	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/FlatCheckBoxUI.java

@@ -42,12 +42,8 @@ import javax.swing.plaf.ComponentUI;
 public class FlatCheckBoxUI
 	extends FlatRadioButtonUI
 {
-	private static ComponentUI instance;
-
 	public static ComponentUI createUI( JComponent c ) {
-		if( instance == null )
-			instance = new FlatCheckBoxUI();
-		return instance;
+		return FlatUIUtils.createSharedUI( FlatCheckBoxUI.class, FlatCheckBoxUI::new );
 	}
 
 	@Override

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

@@ -17,28 +17,33 @@
 package com.formdev.flatlaf.ui;
 
 import static com.formdev.flatlaf.util.UIScale.scale;
+import static com.formdev.flatlaf.util.UIScale.unscale;
 import java.awt.Color;
 import java.awt.Component;
 import java.awt.ComponentOrientation;
 import java.awt.Container;
 import java.awt.Dimension;
+import java.awt.FontMetrics;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
+import java.awt.GraphicsConfiguration;
 import java.awt.Insets;
 import java.awt.LayoutManager;
 import java.awt.Rectangle;
 import java.awt.Shape;
+import java.awt.Toolkit;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.FocusEvent;
 import java.awt.event.FocusListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
 import java.awt.event.MouseListener;
 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.CellRendererPane;
 import javax.swing.DefaultListCellRenderer;
 import javax.swing.InputMap;
 import javax.swing.JButton;
@@ -46,6 +51,8 @@ import javax.swing.JComboBox;
 import javax.swing.JComponent;
 import javax.swing.JList;
 import javax.swing.JPanel;
+import javax.swing.JScrollBar;
+import javax.swing.JTextField;
 import javax.swing.KeyStroke;
 import javax.swing.ListCellRenderer;
 import javax.swing.LookAndFeel;
@@ -54,13 +61,13 @@ import javax.swing.UIManager;
 import javax.swing.border.AbstractBorder;
 import javax.swing.border.Border;
 import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicComboBoxUI;
 import javax.swing.plaf.basic.BasicComboPopup;
 import javax.swing.plaf.basic.ComboPopup;
 import javax.swing.text.JTextComponent;
 import com.formdev.flatlaf.FlatClientProperties;
 import com.formdev.flatlaf.util.SystemInfo;
-import com.formdev.flatlaf.util.UIScale;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JComboBox}.
@@ -76,47 +83,60 @@ import com.formdev.flatlaf.util.UIScale;
  *
  * <!-- FlatComboBoxUI -->
  *
- * @uiDefault Component.focusWidth				int
- * @uiDefault Component.arc						int
- * @uiDefault Component.arrowType				String	triangle (default) or chevron
+ * @uiDefault ComboBox.minimumWidth				int
+ * @uiDefault ComboBox.editorColumns			int
+ * @uiDefault ComboBox.maximumRowCount			int
+ * @uiDefault ComboBox.buttonStyle				String	auto (default), button or none
+ * @uiDefault Component.arrowType				String	chevron (default) or triangle
  * @uiDefault Component.isIntelliJTheme			boolean
  * @uiDefault Component.borderColor				Color
  * @uiDefault Component.disabledBorderColor		Color
  * @uiDefault ComboBox.editableBackground		Color	optional; defaults to ComboBox.background
+ * @uiDefault ComboBox.focusedBackground		Color	optional
  * @uiDefault ComboBox.disabledBackground		Color
  * @uiDefault ComboBox.disabledForeground		Color
  * @uiDefault ComboBox.buttonBackground			Color
  * @uiDefault ComboBox.buttonEditableBackground	Color
+ * @uiDefault ComboBox.buttonFocusedBackground	Color	optional; defaults to ComboBox.focusedBackground
  * @uiDefault ComboBox.buttonArrowColor			Color
  * @uiDefault ComboBox.buttonDisabledArrowColor	Color
  * @uiDefault ComboBox.buttonHoverArrowColor	Color
+ * @uiDefault ComboBox.buttonPressedArrowColor	Color
+ * @uiDefault ComboBox.popupBackground			Color	optional
  *
  * @author Karl Tauber
  */
 public class FlatComboBoxUI
 	extends BasicComboBoxUI
 {
-	protected int focusWidth;
-	protected int arc;
+	protected int minimumWidth;
+	protected int editorColumns;
+	protected String buttonStyle;
 	protected String arrowType;
 	protected boolean isIntelliJTheme;
 	protected Color borderColor;
 	protected Color disabledBorderColor;
 
 	protected Color editableBackground;
+	protected Color focusedBackground;
 	protected Color disabledBackground;
 	protected Color disabledForeground;
 
 	protected Color buttonBackground;
 	protected Color buttonEditableBackground;
+	protected Color buttonFocusedBackground;
 	protected Color buttonArrowColor;
 	protected Color buttonDisabledArrowColor;
 	protected Color buttonHoverArrowColor;
+	protected Color buttonPressedArrowColor;
+
+	protected Color popupBackground;
 
 	private MouseListener hoverListener;
-	private boolean hover;
+	protected boolean hover;
+	protected boolean pressed;
 
-	private WeakReference<Component> lastRendererComponent;
+	private CellPaddingBorder paddingBorder;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatComboBoxUI();
@@ -126,13 +146,36 @@ public class FlatComboBoxUI
 	protected void installListeners() {
 		super.installListeners();
 
-		hoverListener = new FlatUIUtils.HoverListener( null, h -> {
-			if( !comboBox.isEditable() ) {
-				hover = h;
-				if( arrowButton != null )
+		hoverListener = new MouseAdapter() {
+			@Override
+			public void mouseEntered( MouseEvent e ) {
+				hover = true;
+				repaintArrowButton();
+			}
+
+			@Override
+			public void mouseExited( MouseEvent e ) {
+				hover = false;
+				repaintArrowButton();
+			}
+
+			@Override
+			public void mousePressed( MouseEvent e ) {
+				pressed = true;
+				repaintArrowButton();
+			}
+
+			@Override
+			public void mouseReleased( MouseEvent e ) {
+				pressed = false;
+				repaintArrowButton();
+			}
+
+			private void repaintArrowButton() {
+				if( arrowButton != null && !comboBox.isEditable() )
 					arrowButton.repaint();
 			}
-		} );
+		};
 		comboBox.addMouseListener( hoverListener );
 	}
 
@@ -150,27 +193,37 @@ public class FlatComboBoxUI
 
 		LookAndFeel.installProperty( comboBox, "opaque", false );
 
-		focusWidth = UIManager.getInt( "Component.focusWidth" );
-		arc = UIManager.getInt( "Component.arc" );
+		minimumWidth = UIManager.getInt( "ComboBox.minimumWidth" );
+		editorColumns = UIManager.getInt( "ComboBox.editorColumns" );
+		buttonStyle = UIManager.getString( "ComboBox.buttonStyle" );
 		arrowType = UIManager.getString( "Component.arrowType" );
 		isIntelliJTheme = UIManager.getBoolean( "Component.isIntelliJTheme" );
 		borderColor = UIManager.getColor( "Component.borderColor" );
 		disabledBorderColor = UIManager.getColor( "Component.disabledBorderColor" );
 
 		editableBackground = UIManager.getColor( "ComboBox.editableBackground" );
+		focusedBackground = UIManager.getColor( "ComboBox.focusedBackground" );
 		disabledBackground = UIManager.getColor( "ComboBox.disabledBackground" );
 		disabledForeground = UIManager.getColor( "ComboBox.disabledForeground" );
 
 		buttonBackground = UIManager.getColor( "ComboBox.buttonBackground" );
+		buttonFocusedBackground = UIManager.getColor( "ComboBox.buttonFocusedBackground" );
 		buttonEditableBackground = UIManager.getColor( "ComboBox.buttonEditableBackground" );
 		buttonArrowColor = UIManager.getColor( "ComboBox.buttonArrowColor" );
 		buttonDisabledArrowColor = UIManager.getColor( "ComboBox.buttonDisabledArrowColor" );
 		buttonHoverArrowColor = UIManager.getColor( "ComboBox.buttonHoverArrowColor" );
+		buttonPressedArrowColor = UIManager.getColor( "ComboBox.buttonPressedArrowColor" );
 
-		// scale
-		padding = UIScale.scale( padding );
+		popupBackground = UIManager.getColor( "ComboBox.popupBackground" );
 
-		MigLayoutVisualPadding.install( comboBox, focusWidth );
+		// set maximumRowCount
+		int maximumRowCount = UIManager.getInt( "ComboBox.maximumRowCount" );
+		if( maximumRowCount > 0 && maximumRowCount != 8 && comboBox.getMaximumRowCount() == 8 )
+			comboBox.setMaximumRowCount( maximumRowCount );
+
+		paddingBorder = new CellPaddingBorder( padding );
+
+		MigLayoutVisualPadding.install( comboBox );
 	}
 
 	@Override
@@ -181,14 +234,21 @@ public class FlatComboBoxUI
 		disabledBorderColor = null;
 
 		editableBackground = null;
+		focusedBackground = null;
 		disabledBackground = null;
 		disabledForeground = null;
 
 		buttonBackground = null;
 		buttonEditableBackground = null;
+		buttonFocusedBackground = null;
 		buttonArrowColor = null;
 		buttonDisabledArrowColor = null;
 		buttonHoverArrowColor = null;
+		buttonPressedArrowColor = null;
+
+		popupBackground = null;
+
+		paddingBorder.uninstall();
 
 		MigLayoutVisualPadding.uninstall( comboBox );
 	}
@@ -200,9 +260,25 @@ public class FlatComboBoxUI
 			public void layoutContainer( Container parent ) {
 				super.layoutContainer( parent );
 
-				if ( editor != null && padding != null ) {
-					// fix editor bounds by subtracting padding
-					editor.setBounds( FlatUIUtils.subtractInsets( editor.getBounds(), padding ) );
+				if( arrowButton != null ) {
+					// limit button width to height of a raw combobox (without insets)
+					FontMetrics fm = comboBox.getFontMetrics( comboBox.getFont() );
+					int maxButtonWidth = fm.getHeight() + scale( padding.top ) + scale( padding.bottom );
+
+					Insets insets = getInsets();
+					int buttonWidth = Math.min( parent.getPreferredSize().height - insets.top - insets.bottom, maxButtonWidth );
+					if( buttonWidth != arrowButton.getWidth() ) {
+						// set width of arrow button to preferred height of combobox
+						int xOffset = comboBox.getComponentOrientation().isLeftToRight()
+							? arrowButton.getWidth() - buttonWidth
+							: 0;
+						arrowButton.setBounds( arrowButton.getX() + xOffset, arrowButton.getY(),
+							buttonWidth, arrowButton.getHeight() );
+
+						// update editor bounds
+						if( editor != null )
+							editor.setBounds( rectangleForCurrentValue() );
+					}
 				}
 			}
 		};
@@ -230,26 +306,28 @@ public class FlatComboBoxUI
 
 	@Override
 	protected PropertyChangeListener createPropertyChangeListener() {
-		return new BasicComboBoxUI.PropertyChangeHandler() {
-			@Override
-			public void propertyChange( PropertyChangeEvent e ) {
-				super.propertyChange( e );
+		PropertyChangeListener superListener = super.createPropertyChangeListener();
+		return e -> {
+			superListener.propertyChange( e );
 
-				Object source = e.getSource();
-				String propertyName = e.getPropertyName();
+			Object source = e.getSource();
+			String propertyName = e.getPropertyName();
 
-				if( editor != null &&
-					((source == comboBox && propertyName == "foreground") ||
-					 (source == editor && propertyName == "enabled")) )
-				{
-					// fix editor component colors
-					updateEditorColors();
-				} else if( editor != null && source == comboBox && propertyName == "componentOrientation" ) {
-					ComponentOrientation o = (ComponentOrientation) e.getNewValue();
-					editor.applyComponentOrientation( o );
-				} else if( editor != null && FlatClientProperties.PLACEHOLDER_TEXT.equals( propertyName ) )
-					editor.repaint();
-			}
+			if( editor != null &&
+				((source == comboBox && propertyName == "foreground") ||
+				 (source == editor && propertyName == "enabled")) )
+			{
+				// fix editor component colors
+				updateEditorColors();
+			} else if( editor != null && source == comboBox && propertyName == "componentOrientation" ) {
+				ComponentOrientation o = (ComponentOrientation) e.getNewValue();
+				editor.applyComponentOrientation( o );
+			} else if( editor != null && FlatClientProperties.PLACEHOLDER_TEXT.equals( propertyName ) )
+				editor.repaint();
+			else if( FlatClientProperties.COMPONENT_ROUND_RECT.equals( propertyName ) )
+				comboBox.repaint();
+			else if( FlatClientProperties.MINIMUM_WIDTH.equals( propertyName ) )
+				comboBox.revalidate();
 		};
 	}
 
@@ -262,13 +340,21 @@ public class FlatComboBoxUI
 	protected void configureEditor() {
 		super.configureEditor();
 
-		// assign a non-javax.swing.plaf.UIResource border to the text field,
-		// otherwise it is replaced with default text field border when switching LaF
-		// because javax.swing.plaf.basic.BasicComboBoxEditor.BorderlessTextField.setBorder()
-		// uses "border instanceof javax.swing.plaf.basic.BasicComboBoxEditor.UIResource"
-		// instead of "border instanceof javax.swing.plaf.UIResource"
-		if( editor instanceof JTextComponent )
-			((JTextComponent)editor).setBorder( BorderFactory.createEmptyBorder() );
+		if( editor instanceof JTextField ) {
+			JTextField textField = (JTextField) editor;
+			textField.setColumns( editorColumns );
+
+			// remove default text field border from editor
+			Border border = textField.getBorder();
+			if( border == null || border instanceof UIResource ) {
+				// assign a non-null and non-javax.swing.plaf.UIResource border to the text field,
+				// otherwise it is replaced with default text field border when switching LaF
+				// because javax.swing.plaf.basic.BasicComboBoxEditor.BorderlessTextField.setBorder()
+				// uses "border instanceof javax.swing.plaf.basic.BasicComboBoxEditor.UIResource"
+				// instead of "border instanceof javax.swing.plaf.UIResource"
+				textField.setBorder( BorderFactory.createEmptyBorder() );
+			}
+		}
 
 		// explicitly make non-opaque
 		if( editor instanceof JComponent )
@@ -276,10 +362,11 @@ public class FlatComboBoxUI
 
 		editor.applyComponentOrientation( comboBox.getComponentOrientation() );
 
+		updateEditorPadding();
 		updateEditorColors();
 
 		// macOS
-		if( SystemInfo.IS_MAC && editor instanceof JTextComponent ) {
+		if( SystemInfo.isMacOS && 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();
@@ -292,73 +379,102 @@ public class FlatComboBoxUI
 		}
 	}
 
+	private void updateEditorPadding() {
+		if( !(editor instanceof JTextField) )
+			return;
+
+		JTextField textField = (JTextField) editor;
+		Insets insets = textField.getInsets();
+		Insets pad = padding;
+		if( insets.top != 0 || insets.left != 0 || insets.bottom != 0 || insets.right != 0 ) {
+			// if text field has custom border, subtract text field insets from padding
+			pad = new Insets(
+				unscale( Math.max( scale( padding.top ) - insets.top, 0 ) ),
+				unscale( Math.max( scale( padding.left ) - insets.left, 0 ) ),
+				unscale( Math.max( scale( padding.bottom ) - insets.bottom, 0 ) ),
+				unscale( Math.max( scale( padding.right ) - insets.right, 0 ) )
+			);
+		}
+		textField.putClientProperty( FlatClientProperties.TEXT_FIELD_PADDING, pad );
+	}
+
 	private void updateEditorColors() {
 		// use non-UIResource colors because when SwingUtilities.updateComponentTreeUI()
 		// is used, then the editor is updated after the combobox and the
 		// colors are again replaced with default colors
-		boolean enabled = editor.isEnabled();
-		editor.setForeground( FlatUIUtils.nonUIResource( (enabled || editor instanceof JTextComponent)
-			? comboBox.getForeground()
-			: disabledForeground ) );
-		if( editor instanceof JTextComponent )
-			((JTextComponent)editor).setDisabledTextColor( FlatUIUtils.nonUIResource( disabledForeground ) );
+		boolean isTextComponent = editor instanceof JTextComponent;
+		editor.setForeground( FlatUIUtils.nonUIResource( getForeground( isTextComponent || editor.isEnabled() ) ) );
+
+		if( isTextComponent )
+			((JTextComponent)editor).setDisabledTextColor( FlatUIUtils.nonUIResource( getForeground( false ) ) );
 	}
 
 	@Override
 	protected JButton createArrowButton() {
-		return new FlatArrowButton( SwingConstants.SOUTH, arrowType, buttonArrowColor,
-			buttonDisabledArrowColor, buttonHoverArrowColor, null )
-		{
-			@Override
-			protected boolean isHover() {
-				return super.isHover() || (!comboBox.isEditable() ? hover : false);
-			}
-		};
+		return new FlatComboBoxButton();
 	}
 
 	@Override
 	public void update( Graphics g, JComponent c ) {
+		float focusWidth = FlatUIUtils.getBorderFocusWidth( c );
+		float arc = FlatUIUtils.getBorderArc( c );
+		boolean paintBackground = true;
+
+		// check whether used as cell renderer
+		boolean isCellRenderer = c.getParent() instanceof CellRendererPane;
+		if( isCellRenderer ) {
+			focusWidth = 0;
+			arc = 0;
+			paintBackground = isCellRendererBackgroundChanged();
+		}
+
 		// fill background if opaque to avoid garbage if user sets opaque to true
-		if( c.isOpaque() && (focusWidth > 0 || arc != 0) )
+		if( c.isOpaque() && (focusWidth > 0 || arc > 0) )
 			FlatUIUtils.paintParentBackground( g, c );
 
 		Graphics2D g2 = (Graphics2D) g;
-		FlatUIUtils.setRenderingHints( g2 );
+		Object[] oldRenderingHints = FlatUIUtils.setRenderingHints( g2 );
 
 		int width = c.getWidth();
 		int height = c.getHeight();
-		float focusWidth = (c.getBorder() instanceof FlatBorder) ? scale( (float) this.focusWidth ) : 0;
-		float arc = (c.getBorder() instanceof FlatRoundBorder) ? scale( (float) this.arc ) : 0;
 		int arrowX = arrowButton.getX();
 		int arrowWidth = arrowButton.getWidth();
+		boolean paintButton = (comboBox.isEditable() || "button".equals( buttonStyle )) && !"none".equals( buttonStyle );
 		boolean enabled = comboBox.isEnabled();
 		boolean isLeftToRight = comboBox.getComponentOrientation().isLeftToRight();
 
 		// paint background
-		g2.setColor( enabled
-			? (editableBackground != null && comboBox.isEditable() ? editableBackground : c.getBackground())
-			: getDisabledBackground( comboBox ) );
-		FlatUIUtils.paintComponentBackground( g2, 0, 0, width, height, focusWidth, arc );
-
-		// paint arrow button background
-		if( enabled ) {
-			g2.setColor( comboBox.isEditable() ? buttonEditableBackground : buttonBackground );
-			Shape oldClip = g2.getClip();
-			if( isLeftToRight )
-				g2.clipRect( arrowX, 0, width - arrowX, height );
-			else
-				g2.clipRect( 0, 0, arrowX + arrowWidth, height );
+		if( paintBackground || c.isOpaque() ) {
+			g2.setColor( getBackground( enabled ) );
 			FlatUIUtils.paintComponentBackground( g2, 0, 0, width, height, focusWidth, arc );
-			g2.setClip( oldClip );
+
+			// paint arrow button background
+			if( enabled && !isCellRenderer ) {
+				g2.setColor( paintButton
+					? buttonEditableBackground
+					: (buttonFocusedBackground != null || focusedBackground != null) && isPermanentFocusOwner( comboBox )
+						? (buttonFocusedBackground != null ? buttonFocusedBackground : focusedBackground)
+						: buttonBackground );
+				Shape oldClip = g2.getClip();
+				if( isLeftToRight )
+					g2.clipRect( arrowX, 0, width - arrowX, height );
+				else
+					g2.clipRect( 0, 0, arrowX + arrowWidth, height );
+				FlatUIUtils.paintComponentBackground( g2, 0, 0, width, height, focusWidth, arc );
+				g2.setClip( oldClip );
+			}
+
+			// paint vertical line between value and arrow button
+			if( paintButton ) {
+				g2.setColor( enabled ? borderColor : disabledBorderColor );
+				float lw = scale( 1f );
+				float lx = isLeftToRight ? arrowX : arrowX + arrowWidth - lw;
+				g2.fill( new Rectangle2D.Float( lx, focusWidth, lw, height - 1 - (focusWidth * 2)) );
+			}
 		}
 
-		// paint vertical line between value and arrow button
-		if( comboBox.isEditable() ) {
-			g2.setColor( enabled ? borderColor : disabledBorderColor );
-			float lw = scale( 1f );
-			float lx = isLeftToRight ? arrowX : arrowX + arrowWidth - lw;
-			g2.fill( new Rectangle2D.Float( lx, focusWidth, lw, height - 1 - (focusWidth * 2)) );
-		}
+		// avoid that the "current value" renderer is invoked with enabled antialiasing
+		FlatUIUtils.resetRenderingHints( g2, oldRenderingHints );
 
 		paint( g, c );
 	}
@@ -366,94 +482,161 @@ public class FlatComboBoxUI
 	@Override
 	@SuppressWarnings( "unchecked" )
 	public void paintCurrentValue( Graphics g, Rectangle bounds, boolean hasFocus ) {
+		paddingBorder.uninstall();
+
 		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() );
-		uninstallCellPaddingBorder( c );
 
 		boolean enabled = comboBox.isEnabled();
-		c.setForeground( enabled ? comboBox.getForeground() : disabledForeground );
-		c.setBackground( enabled ? comboBox.getBackground() : getDisabledBackground( comboBox ) );
+		c.setBackground( getBackground( enabled ) );
+		c.setForeground( getForeground( enabled ) );
+
+		// make renderer component temporary non-opaque to avoid that renderer paints
+		// background outside of border if combobox uses larger arc for edges
+		// (e.g. FlatClientProperties.COMPONENT_ROUND_RECT is true)
+		if( c instanceof JComponent )
+			((JComponent)c).setOpaque( false );
 
 		boolean shouldValidate = (c instanceof JPanel);
-		if( padding != null )
-			bounds = FlatUIUtils.subtractInsets( bounds, padding );
-
-		// increase the size of the rendering area to make sure that the text
-		// is vertically aligned with other component types (e.g. JTextField)
-		Insets rendererInsets = getRendererComponentInsets( c );
-		if( rendererInsets != null )
-			bounds = FlatUIUtils.addInsets( bounds, rendererInsets );
 
+		paddingBorder.install( c );
 		currentValuePane.paintComponent( g, c, comboBox, bounds.x, bounds.y, bounds.width, bounds.height, shouldValidate );
+		paddingBorder.uninstall();
+
+		if( c instanceof JComponent )
+			((JComponent)c).setOpaque( true );
 	}
 
 	@Override
 	public void paintCurrentValueBackground( Graphics g, Rectangle bounds, boolean hasFocus ) {
-		g.setColor( comboBox.isEnabled() ? comboBox.getBackground() : getDisabledBackground( comboBox ) );
-		g.fillRect( bounds.x, bounds.y, bounds.width, bounds.height );
+		// not necessary because already painted in update()
 	}
 
-	private Color getDisabledBackground( JComponent c ) {
-		return isIntelliJTheme ? FlatUIUtils.getParentBackground( c ) : disabledBackground;
+	protected Color getBackground( boolean enabled ) {
+		if( enabled ) {
+			Color background = comboBox.getBackground();
+
+			// always use explicitly set color
+			if( !(background instanceof UIResource) )
+				return background;
+
+			// focused
+			if( focusedBackground != null && isPermanentFocusOwner( comboBox ) )
+				return focusedBackground;
+
+			return (editableBackground != null && comboBox.isEditable()) ? editableBackground : background;
+		} else
+			return isIntelliJTheme ? FlatUIUtils.getParentBackground( comboBox ) : disabledBackground;
+	}
+
+	protected Color getForeground( boolean enabled ) {
+		return enabled ? comboBox.getForeground() : disabledForeground;
+	}
+
+	@Override
+	public Dimension getMinimumSize( JComponent c ) {
+		Dimension minimumSize = super.getMinimumSize( c );
+		int fw = Math.round( FlatUIUtils.getBorderFocusWidth( c ) * 2 );
+		minimumSize.width = Math.max( minimumSize.width, scale( FlatUIUtils.minimumWidth( c, minimumWidth ) ) + fw );
+		return minimumSize;
 	}
 
 	@Override
 	protected Dimension getDefaultSize() {
-		@SuppressWarnings( "unchecked" )
-		ListCellRenderer<Object> renderer = comboBox.getRenderer();
-		uninstallCellPaddingBorder( renderer );
-
+		paddingBorder.uninstall();
 		Dimension size = super.getDefaultSize();
-
-		uninstallCellPaddingBorder( renderer );
+		paddingBorder.uninstall();
 		return size;
 	}
 
 	@Override
 	protected Dimension getDisplaySize() {
-		@SuppressWarnings( "unchecked" )
-		ListCellRenderer<Object> renderer = comboBox.getRenderer();
-		uninstallCellPaddingBorder( renderer );
-
+		paddingBorder.uninstall();
 		Dimension displaySize = super.getDisplaySize();
+		paddingBorder.uninstall();
 
-		uninstallCellPaddingBorder( renderer );
-		return displaySize;
+		// remove padding added in super.getDisplaySize()
+		int displayWidth = displaySize.width - padding.left - padding.right;
+		int displayHeight = displaySize.height - padding.top - padding.bottom;
+
+		// recalculate width without hardcoded 100 under special conditions
+		if( displayWidth == 100 &&
+			comboBox.isEditable() &&
+			comboBox.getItemCount() == 0 &&
+			comboBox.getPrototypeDisplayValue() == null )
+		{
+			displayWidth = Math.max( getDefaultSize().width, editor.getPreferredSize().width );
+		}
+
+		return new Dimension( displayWidth, displayHeight );
 	}
 
 	@Override
 	protected Dimension getSizeForComponent( Component comp ) {
+		paddingBorder.install( comp );
 		Dimension size = super.getSizeForComponent( comp );
-
-		// remove the renderer border top/bottom insets from the size to make sure that
-		// the combobox gets the same height as other component types (e.g. JTextField)
-		Insets rendererInsets = getRendererComponentInsets( comp );
-		if( rendererInsets != null )
-			size = new Dimension( size.width, size.height - rendererInsets.top - rendererInsets.bottom );
-
+		paddingBorder.uninstall();
 		return size;
 	}
 
-	private Insets getRendererComponentInsets( Component rendererComponent ) {
-		if( rendererComponent instanceof JComponent ) {
-			Border rendererBorder = ((JComponent)rendererComponent).getBorder();
-			if( rendererBorder != null )
-				return rendererBorder.getBorderInsets( rendererComponent );
-		}
-
-		return null;
+	private boolean isCellRenderer() {
+		return comboBox.getParent() instanceof CellRendererPane;
 	}
 
-	private void uninstallCellPaddingBorder( Object o ) {
-		CellPaddingBorder.uninstall( o );
-		if( lastRendererComponent != null ) {
-			CellPaddingBorder.uninstall( lastRendererComponent );
-			lastRendererComponent = null;
+	private boolean isCellRendererBackgroundChanged() {
+		// parent is a CellRendererPane, parentParent is e.g. a JTable
+		Container parentParent = comboBox.getParent().getParent();
+		return parentParent != null && !comboBox.getBackground().equals( parentParent.getBackground() );
+	}
+
+	/**
+	 * @since 1.3
+	 */
+	public static boolean isPermanentFocusOwner( JComboBox<?> comboBox ) {
+		if( comboBox.isEditable() ) {
+			Component editorComponent = comboBox.getEditor().getEditorComponent();
+			return (editorComponent != null) ? FlatUIUtils.isPermanentFocusOwner( editorComponent ) : false;
+		} else
+			return FlatUIUtils.isPermanentFocusOwner( comboBox );
+	}
+
+	//---- class FlatComboBoxButton -------------------------------------------
+
+	protected class FlatComboBoxButton
+		extends FlatArrowButton
+	{
+		protected FlatComboBoxButton() {
+			this( SwingConstants.SOUTH, arrowType, buttonArrowColor, buttonDisabledArrowColor,
+				buttonHoverArrowColor, null, buttonPressedArrowColor, null );
+		}
+
+		protected FlatComboBoxButton( int direction, String type, Color foreground, Color disabledForeground,
+			Color hoverForeground, Color hoverBackground, Color pressedForeground, Color pressedBackground )
+		{
+			super( direction, type, foreground, disabledForeground,
+				hoverForeground, hoverBackground, pressedForeground, pressedBackground );
+		}
+
+		@Override
+		protected boolean isHover() {
+			return super.isHover() || (!comboBox.isEditable() ? hover : false);
+		}
+
+		@Override
+		protected boolean isPressed() {
+			return super.isPressed() || (!comboBox.isEditable() ? pressed : false);
+		}
+
+		@Override
+		protected Color getArrowColor() {
+			if( isCellRenderer() && isCellRendererBackgroundChanged() )
+				return comboBox.getForeground();
+
+			return super.getArrowColor();
 		}
 	}
 
@@ -463,13 +646,11 @@ public class FlatComboBoxUI
 	protected class FlatComboPopup
 		extends BasicComboPopup
 	{
-		private CellPaddingBorder paddingBorder;
-
 		protected FlatComboPopup( JComboBox combo ) {
 			super( combo );
 
 			// BasicComboPopup listens to JComboBox.componentOrientation and updates
-			// the component orientation of the list, scroller and popup, but when
+			// the component orientation of the list, scroll pane and popup, but when
 			// switching the LaF and a new combo popup is created, the component
 			// orientation is not applied.
 			ComponentOrientation o = comboBox.getComponentOrientation();
@@ -480,13 +661,37 @@ public class FlatComboBoxUI
 
 		@Override
 		protected Rectangle computePopupBounds( int px, int py, int pw, int ph ) {
-			// get maximum display size of all items
-			Dimension displaySize = getDisplaySize();
+			// get maximum display width of all items
+			int displayWidth = getDisplaySize().width;
+
+			// add border insets
+			for( Border border : new Border[] { scroller.getViewportBorder(), scroller.getBorder() } ) {
+				if( border != null ) {
+					Insets borderInsets = border.getBorderInsets( null );
+					displayWidth += borderInsets.left + borderInsets.right;
+				}
+			}
+
+			// add width of vertical scroll bar
+			JScrollBar verticalScrollBar = scroller.getVerticalScrollBar();
+			if( verticalScrollBar != null )
+				displayWidth += verticalScrollBar.getPreferredSize().width;
 
 			// make popup wider if necessary
-			if( displaySize.width > pw ) {
-				int diff = displaySize.width - pw;
-				pw = displaySize.width;
+			if( displayWidth > pw ) {
+				// limit popup width to screen width
+				GraphicsConfiguration gc = comboBox.getGraphicsConfiguration();
+				if( gc != null ) {
+					Rectangle screenBounds = gc.getBounds();
+					Insets screenInsets = Toolkit.getDefaultToolkit().getScreenInsets( gc );
+					displayWidth = Math.min( displayWidth, screenBounds.width - screenInsets.left - screenInsets.right );
+				} else {
+					Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
+					displayWidth = Math.min( displayWidth, screenSize.width );
+				}
+
+				int diff = displayWidth - pw;
+				pw = displayWidth;
 
 				if( !comboBox.getComponentOrientation().isLeftToRight() )
 					px -= diff;
@@ -499,6 +704,9 @@ public class FlatComboBoxUI
 		protected void configurePopup() {
 			super.configurePopup();
 
+			// make opaque to avoid that background shines thru border (e.g. at 150% scaling)
+			setOpaque( true );
+
 			Border border = UIManager.getBorder( "PopupMenu.border" );
 			if( border != null )
 				setBorder( border );
@@ -509,21 +717,49 @@ public class FlatComboBoxUI
 			super.configureList();
 
 			list.setCellRenderer( new PopupListCellRenderer() );
+			if( popupBackground != null )
+		        list.setBackground( popupBackground );
 		}
 
 		@Override
 		protected PropertyChangeListener createPropertyChangeListener() {
-			return new BasicComboPopup.PropertyChangeHandler() {
-				@Override
-				public void propertyChange( PropertyChangeEvent e ) {
-					super.propertyChange( e );
+			PropertyChangeListener superListener = super.createPropertyChangeListener();
+			return e -> {
+				superListener.propertyChange( e );
 
-					if( e.getPropertyName() == "renderer" )
-						list.setCellRenderer( new PopupListCellRenderer() );
-				}
+				if( e.getPropertyName() == "renderer" )
+					list.setCellRenderer( new PopupListCellRenderer() );
 			};
 		}
 
+		@Override
+		protected int getPopupHeightForRowCount( int maxRowCount ) {
+			int height = super.getPopupHeightForRowCount( maxRowCount );
+			paddingBorder.uninstall();
+			return height;
+		}
+
+		@Override
+		public void show( Component invoker, int x, int y ) {
+			// Java 8: fix y coordinate if popup is shown above the combobox
+			// (already fixed in Java 9+ https://bugs.openjdk.java.net/browse/JDK-7072653)
+			if( y < 0 && !SystemInfo.isJava_9_orLater ) {
+				Border popupBorder = getBorder();
+				if( popupBorder != null ) {
+					Insets insets = popupBorder.getBorderInsets( this );
+					y -= insets.top + insets.bottom;
+				}
+			}
+
+			super.show( invoker, x, y );
+		}
+
+		@Override
+		protected void paintChildren( Graphics g ) {
+			super.paintChildren( g );
+			paddingBorder.uninstall();
+		}
+
 		//---- class PopupListCellRenderer -----
 
 		private class PopupListCellRenderer
@@ -533,22 +769,15 @@ public class FlatComboBoxUI
 			public Component getListCellRendererComponent( JList list, Object value,
 				int index, boolean isSelected, boolean cellHasFocus )
 			{
-				ListCellRenderer renderer = comboBox.getRenderer();
-				CellPaddingBorder.uninstall( renderer );
-				CellPaddingBorder.uninstall( lastRendererComponent );
+				paddingBorder.uninstall();
 
+				ListCellRenderer renderer = comboBox.getRenderer();
 				if( renderer == null )
 					renderer = new DefaultListCellRenderer();
 				Component c = renderer.getListCellRendererComponent( list, value, index, isSelected, cellHasFocus );
 				c.applyComponentOrientation( comboBox.getComponentOrientation() );
 
-				if( c instanceof JComponent ) {
-					if( paddingBorder == null )
-						paddingBorder = new CellPaddingBorder( padding );
-					paddingBorder.install( (JComponent) c );
-				}
-
-				lastRendererComponent = (c != renderer) ? new WeakReference<>( c ) : null;
+				paddingBorder.install( c );
 
 				return c;
 			}
@@ -558,49 +787,69 @@ public class FlatComboBoxUI
 	//---- class CellPaddingBorder --------------------------------------------
 
 	/**
-	 * Cell padding border used only in popup list.
-	 *
+	 * Cell padding border used in popup list and for current value if not editable.
+	 * <p>
 	 * The insets are the union of the cell padding and the renderer border insets,
 	 * which vertically aligns text in popup list with text in combobox.
-	 *
-	 * The renderer border is painted on the outside of this border.
+	 * <p>
+	 * The renderer border is painted on the outer side of this border.
 	 */
 	private static class CellPaddingBorder
 		extends AbstractBorder
 	{
 		private final Insets padding;
+		private JComponent rendererComponent;
 		private Border rendererBorder;
 
 		CellPaddingBorder( Insets padding ) {
 			this.padding = padding;
 		}
 
-		void install( JComponent rendererComponent ) {
-			Border oldBorder = rendererComponent.getBorder();
-			if( !(oldBorder instanceof CellPaddingBorder) ) {
-				rendererBorder = oldBorder;
-				rendererComponent.setBorder( this );
-			}
-		}
-
-		static void uninstall( Object o ) {
-			if( o instanceof WeakReference )
-				o = ((WeakReference<?>)o).get();
-
-			if( !(o instanceof JComponent) )
+		void install( Component c ) {
+			if( !(c instanceof JComponent) )
 				return;
 
-			JComponent rendererComponent = (JComponent) o;
-			Border border = rendererComponent.getBorder();
-			if( border instanceof CellPaddingBorder ) {
-				CellPaddingBorder paddingBorder = (CellPaddingBorder) border;
-				rendererComponent.setBorder( paddingBorder.rendererBorder );
-				paddingBorder.rendererBorder = null;
-			}
+			JComponent jc = (JComponent) c;
+			Border oldBorder = jc.getBorder();
+			if( oldBorder == this )
+				return; // already installed
+
+			// component already has a padding border --> uninstall it
+			// (may happen if single renderer instance is used in multiple comboboxes)
+			if( oldBorder instanceof CellPaddingBorder )
+				((CellPaddingBorder)oldBorder).uninstall();
+
+			// this border can be installed only at one component
+			// (may happen if a renderer returns varying components)
+			uninstall();
+
+			// remember component where this border was installed for uninstall
+			rendererComponent = jc;
+
+			// remember old border and replace it
+			rendererBorder = jc.getBorder();
+			jc.setBorder( this );
+		}
+
+		/**
+		 * Uninstall border from previously installed component.
+		 * Because this border is installed in PopupListCellRenderer.getListCellRendererComponent(),
+		 * there is no single place to uninstall it.
+		 * This is the reason why this method is called from various places.
+		 */
+		void uninstall() {
+			if( rendererComponent == null )
+				return;
+
+			if( rendererComponent.getBorder() == this )
+				rendererComponent.setBorder( rendererBorder );
+			rendererComponent = null;
+			rendererBorder = null;
 		}
 
 		@Override
 		public Insets getBorderInsets( Component c, Insets insets ) {
+			Insets padding = scale( this.padding );
 			if( rendererBorder != null ) {
 				Insets insideInsets = rendererBorder.getBorderInsets( c );
 				insets.top = Math.max( padding.top, insideInsets.top );

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

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

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

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

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

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

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

@@ -17,15 +17,21 @@
 package com.formdev.flatlaf.ui;
 
 import static com.formdev.flatlaf.util.UIScale.scale;
+import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Insets;
+import java.awt.event.FocusListener;
+import java.beans.PropertyChangeEvent;
 import javax.swing.JComponent;
 import javax.swing.JEditorPane;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
-import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicEditorPaneUI;
 import javax.swing.text.JTextComponent;
+import com.formdev.flatlaf.FlatClientProperties;
+import com.formdev.flatlaf.util.HiDPIUtils;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JEditorPane}.
@@ -49,6 +55,7 @@ import javax.swing.text.JTextComponent;
  *
  * @uiDefault Component.minimumWidth			int
  * @uiDefault Component.isIntelliJTheme			boolean
+ * @uiDefault EditorPane.focusedBackground		Color	optional
  *
  * @author Karl Tauber
  */
@@ -57,8 +64,12 @@ public class FlatEditorPaneUI
 {
 	protected int minimumWidth;
 	protected boolean isIntelliJTheme;
+	protected Color focusedBackground;
+
+	private Insets defaultMargin;
 
 	private Object oldHonorDisplayProperties;
+	private FocusListener focusListener;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatEditorPaneUI();
@@ -68,8 +79,12 @@ public class FlatEditorPaneUI
 	protected void installDefaults() {
 		super.installDefaults();
 
+		String prefix = getPropertyPrefix();
 		minimumWidth = UIManager.getInt( "Component.minimumWidth" );
 		isIntelliJTheme = UIManager.getBoolean( "Component.isIntelliJTheme" );
+		focusedBackground = UIManager.getColor( prefix + ".focusedBackground" );
+
+		defaultMargin = UIManager.getInsets( prefix + ".margin" );
 
 		// use component font and foreground for HTML text
 		oldHonorDisplayProperties = getComponent().getClientProperty( JEditorPane.HONOR_DISPLAY_PROPERTIES );
@@ -80,39 +95,78 @@ public class FlatEditorPaneUI
 	protected void uninstallDefaults() {
 		super.uninstallDefaults();
 
+		focusedBackground = null;
+
 		getComponent().putClientProperty( JEditorPane.HONOR_DISPLAY_PROPERTIES, oldHonorDisplayProperties );
 	}
 
+	@Override
+	protected void installListeners() {
+		super.installListeners();
+
+		// necessary to update focus background
+		focusListener = new FlatUIUtils.RepaintFocusListener( getComponent(), c -> focusedBackground != null );
+		getComponent().addFocusListener( focusListener );
+	}
+
+	@Override
+	protected void uninstallListeners() {
+		super.uninstallListeners();
+
+		getComponent().removeFocusListener( focusListener );
+		focusListener = null;
+	}
+
+	@Override
+	protected void propertyChange( PropertyChangeEvent e ) {
+		super.propertyChange( e );
+		propertyChange( getComponent(), e );
+	}
+
+	static void propertyChange( JTextComponent c, PropertyChangeEvent e ) {
+		switch( e.getPropertyName() ) {
+			case FlatClientProperties.MINIMUM_WIDTH:
+				c.revalidate();
+				break;
+		}
+	}
+
 	@Override
 	public Dimension getPreferredSize( JComponent c ) {
-		return applyMinimumWidth( super.getPreferredSize( c ) );
+		return applyMinimumWidth( c, super.getPreferredSize( c ), minimumWidth, defaultMargin );
 	}
 
 	@Override
 	public Dimension getMinimumSize( JComponent c ) {
-		return applyMinimumWidth( super.getMinimumSize( c ) );
+		return applyMinimumWidth( c, super.getMinimumSize( c ), minimumWidth, defaultMargin );
 	}
 
-	private Dimension applyMinimumWidth( Dimension size ) {
+	static Dimension applyMinimumWidth( JComponent c, Dimension size, int minimumWidth, Insets defaultMargin ) {
+		// do not apply minimum width if JTextComponent.margin is set
+		if( !FlatTextFieldUI.hasDefaultMargins( c, defaultMargin ) )
+			return size;
+
 		// Assume that text area is in a scroll pane (that displays the border)
 		// and subtract 1px border line width.
 		// Using "(scale( 1 ) * 2)" instead of "scale( 2 )" to deal with rounding
 		// issues. E.g. at scale factor 1.5 the first returns 4, but the second 3.
-		int minimumWidth = FlatUIUtils.minimumWidth( getComponent(), this.minimumWidth );
+		minimumWidth = FlatUIUtils.minimumWidth( c, minimumWidth );
 		size.width = Math.max( size.width, scale( minimumWidth ) - (scale( 1 ) * 2) );
 		return size;
 	}
 
+	@Override
+	protected void paintSafely( Graphics g ) {
+		super.paintSafely( HiDPIUtils.createGraphicsTextYCorrection( (Graphics2D) g ) );
+	}
+
 	@Override
 	protected void paintBackground( Graphics g ) {
-		JTextComponent c = getComponent();
+		paintBackground( g, getComponent(), isIntelliJTheme, focusedBackground );
+	}
 
-		// for compatibility with IntelliJ themes
-		if( isIntelliJTheme && (!c.isEnabled() || !c.isEditable()) && (c.getBackground() instanceof UIResource) ) {
-			FlatUIUtils.paintParentBackground( g, c );
-			return;
-		}
-
-		super.paintBackground( g );
+	static void paintBackground( Graphics g, JTextComponent c, boolean isIntelliJTheme, Color focusedBackground ) {
+		g.setColor( FlatTextFieldUI.getBackground( c, isIntelliJTheme, focusedBackground ) );
+		g.fillRect( 0, 0, c.getWidth(), c.getHeight() );
 	}
 }

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

@@ -57,4 +57,8 @@ public class FlatEmptyBorder
 		insets.bottom = scale( bottom );
 		return insets;
 	}
+
+	public Insets getUnscaledBorderInsets() {
+		return super.getBorderInsets();
+	}
 }

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

@@ -16,11 +16,32 @@
 
 package com.formdev.flatlaf.ui;
 
+import java.awt.BorderLayout;
+import java.awt.Component;
 import java.awt.Dimension;
+import java.awt.Insets;
+import java.io.File;
+import javax.swing.AbstractButton;
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.Icon;
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
+import javax.swing.JComboBox;
 import javax.swing.JComponent;
 import javax.swing.JFileChooser;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.JToggleButton;
+import javax.swing.UIManager;
+import javax.swing.filechooser.FileView;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.metal.MetalFileChooserUI;
+import javax.swing.table.TableCellRenderer;
+import com.formdev.flatlaf.FlatClientProperties;
+import com.formdev.flatlaf.util.ScaledImageIcon;
+import com.formdev.flatlaf.util.SystemInfo;
 import com.formdev.flatlaf.util.UIScale;
 
 /**
@@ -86,6 +107,7 @@ import com.formdev.flatlaf.util.UIScale;
  * @uiDefault FileChooser.folderNameLabelText					String
  * @uiDefault FileChooser.filesOfTypeLabelMnemonic				String
  * @uiDefault FileChooser.filesOfTypeLabelText					String
+ *
  * @uiDefault FileChooser.upFolderToolTipText					String
  * @uiDefault FileChooser.upFolderAccessibleName				String
  * @uiDefault FileChooser.homeFolderToolTipText					String
@@ -97,11 +119,27 @@ import com.formdev.flatlaf.util.UIScale;
  * @uiDefault FileChooser.detailsViewButtonToolTipText			String
  * @uiDefault FileChooser.detailsViewButtonAccessibleName		String
  *
+ * <!-- FilePane -->
+ *
+ * @uiDefault FileChooser.fileNameHeaderText					String
+ * @uiDefault FileChooser.fileSizeHeaderText					String
+ * @uiDefault FileChooser.fileTypeHeaderText					String
+ * @uiDefault FileChooser.fileDateHeaderText					String
+ * @uiDefault FileChooser.fileAttrHeaderText					String
+ *
+ * @uiDefault FileChooser.viewMenuLabelText						String
+ * @uiDefault FileChooser.refreshActionLabelText				String
+ * @uiDefault FileChooser.newFolderActionLabelText				String
+ * @uiDefault FileChooser.listViewActionLabelText				String
+ * @uiDefault FileChooser.detailsViewActionLabelText			String
+ *
  * @author Karl Tauber
  */
 public class FlatFileChooserUI
 	extends MetalFileChooserUI
 {
+	private final FlatFileView fileView = new FlatFileView();
+
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatFileChooserUI( (JFileChooser) c );
 	}
@@ -110,6 +148,108 @@ public class FlatFileChooserUI
 		super( filechooser );
 	}
 
+	@Override
+	public void installComponents( JFileChooser fc ) {
+		super.installComponents( fc );
+
+		patchUI( fc );
+	}
+
+	private void patchUI( JFileChooser fc ) {
+		// turn top-right buttons into toolbar buttons
+		Component topPanel = fc.getComponent( 0 );
+		if( (topPanel instanceof JPanel) &&
+			(((JPanel)topPanel).getLayout() instanceof BorderLayout) )
+		{
+			Component topButtonPanel = ((JPanel)topPanel).getComponent( 0 );
+			if( (topButtonPanel instanceof JPanel) &&
+				(((JPanel)topButtonPanel).getLayout() instanceof BoxLayout) )
+			{
+				Insets margin = UIManager.getInsets( "Button.margin" );
+				Component[] comps = ((JPanel)topButtonPanel).getComponents();
+				for( int i = comps.length - 1; i >= 0; i-- ) {
+					Component c = comps[i];
+					if( c instanceof JButton || c instanceof JToggleButton ) {
+						AbstractButton b = (AbstractButton)c;
+						b.putClientProperty( FlatClientProperties.BUTTON_TYPE,
+							FlatClientProperties.BUTTON_TYPE_TOOLBAR_BUTTON );
+						b.setMargin( margin );
+						b.setFocusable( false );
+					} else if( c instanceof Box.Filler )
+						((JPanel)topButtonPanel).remove( i );
+				}
+			}
+		}
+
+		// increase maximum row count of directory combo box popup list
+		try {
+			Component directoryComboBox =  ((JPanel)topPanel).getComponent( 2 );
+			if( directoryComboBox instanceof JComboBox ) {
+				int maximumRowCount = UIManager.getInt( "ComboBox.maximumRowCount" );
+				if( maximumRowCount > 0 )
+					((JComboBox<?>)directoryComboBox).setMaximumRowCount( maximumRowCount );
+			}
+		} catch( ArrayIndexOutOfBoundsException ex ) {
+			// ignore
+		}
+	}
+
+	@Override
+	protected JPanel createDetailsView( JFileChooser fc ) {
+		JPanel p = super.createDetailsView( fc );
+
+		if( !SystemInfo.isWindows )
+			return p;
+
+		// find scroll pane
+		JScrollPane scrollPane = null;
+		for( Component c : p.getComponents() ) {
+			if( c instanceof JScrollPane ) {
+				scrollPane = (JScrollPane) c;
+				break;
+			}
+		}
+		if( scrollPane == null )
+			return p;
+
+		// get scroll view, which should be a table
+		Component view = scrollPane.getViewport().getView();
+		if( !(view instanceof JTable) )
+			return p;
+
+		JTable table = (JTable) view;
+
+		// on Windows 10, the date may contain left-to-right (0x200e) and right-to-left (0x200f)
+		// mark characters (see https://en.wikipedia.org/wiki/Left-to-right_mark)
+		// when the "current user" item is selected in the "look in" combobox
+		// --> remove them
+		TableCellRenderer defaultRenderer = table.getDefaultRenderer( Object.class );
+		table.setDefaultRenderer( Object.class, new TableCellRenderer() {
+			@Override
+			public Component getTableCellRendererComponent( JTable table, Object value, boolean isSelected,
+				boolean hasFocus, int row, int column )
+			{
+				// remove left-to-right and right-to-left mark characters
+				if( value instanceof String && ((String)value).startsWith( "\u200e" ) ) {
+					String str = (String) value;
+					char[] buf = new char[str.length()];
+					int j = 0;
+					for( int i = 0; i < buf.length; i++ ) {
+						char ch = str.charAt( i );
+						if( ch != '\u200e' && ch != '\u200f' )
+							buf[j++] = ch;
+					}
+					value = new String( buf, 0, j );
+				}
+
+				return defaultRenderer.getTableCellRendererComponent( table, value, isSelected, hasFocus, row, column );
+			}
+
+		} );
+
+		return p;
+	}
+
 	@Override
 	public Dimension getPreferredSize( JComponent c ) {
 		return UIScale.scale( super.getPreferredSize( c ) );
@@ -119,4 +259,58 @@ public class FlatFileChooserUI
 	public Dimension getMinimumSize( JComponent c ) {
 		return UIScale.scale( super.getMinimumSize( c ) );
 	}
+
+	@Override
+	public FileView getFileView( JFileChooser fc ) {
+		return doNotUseSystemIcons() ? super.getFileView( fc ) : fileView;
+	}
+
+	@Override
+	public void clearIconCache() {
+		if( doNotUseSystemIcons() )
+			super.clearIconCache();
+		else
+			fileView.clearIconCache();
+	}
+
+	private boolean doNotUseSystemIcons() {
+		// Java 17 32bit craches on Windows when using system icons
+		return SystemInfo.isWindows && SystemInfo.isJava_17_orLater && !SystemInfo.isX86_64;
+	}
+
+	//---- class FlatFileView -------------------------------------------------
+
+	private class FlatFileView
+		extends BasicFileView
+	{
+		@Override
+		public Icon getIcon( File f ) {
+			// get cached icon
+			Icon icon = getCachedIcon( f );
+			if( icon != null )
+				return icon;
+
+			// get system icon
+			if( f != null ) {
+				icon = getFileChooser().getFileSystemView().getSystemIcon( f );
+
+				if( icon != null ) {
+					if( icon instanceof ImageIcon )
+						icon = new ScaledImageIcon( (ImageIcon) icon );
+					cacheIcon( f, icon );
+					return icon;
+				}
+			}
+
+			// get default icon
+			icon = super.getIcon( f );
+
+			if( icon instanceof ImageIcon ) {
+				icon = new ScaledImageIcon( (ImageIcon) icon );
+				cacheIcon( f, icon );
+			}
+
+			return icon;
+		}
+	}
 }

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

@@ -39,12 +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 FormattedTextField.focusedBackground		Color	optional
  * @uiDefault TextComponent.selectAllOnFocusPolicy		String	never, once (default) or always
+ * @uiDefault TextComponent.selectAllOnMouseClick		boolean
  *
  * @author Karl Tauber
  */

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

@@ -21,18 +21,20 @@ import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.awt.LayoutManager;
+import java.awt.Rectangle;
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
 import javax.swing.BorderFactory;
 import javax.swing.BoxLayout;
 import javax.swing.Icon;
+import javax.swing.ImageIcon;
 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.ScaledImageIcon;
 import com.formdev.flatlaf.util.UIScale;
 
 /**
@@ -91,7 +93,21 @@ public class FlatInternalFrameTitlePane
 		updateFrameIcon();
 		updateColors();
 
-		buttonPanel = new JPanel();
+		buttonPanel = new JPanel() {
+			@Override
+			public Dimension getPreferredSize() {
+				Dimension size = super.getPreferredSize();
+				int height = size.height;
+				// use height of invisible buttons to always have same title pane height
+				if( !iconButton.isVisible() )
+					height = Math.max( height, iconButton.getPreferredSize().height );
+				if( !maxButton.isVisible() )
+					height = Math.max( height, maxButton.getPreferredSize().height );
+				if( !closeButton.isVisible() )
+					height = Math.max( height, closeButton.getPreferredSize().height );
+				return new Dimension( size.width, height );
+			}
+		};
 		buttonPanel.setLayout( new BoxLayout( buttonPanel, BoxLayout.LINE_AXIS ) );
 		buttonPanel.setOpaque( false );
 
@@ -103,14 +119,16 @@ public class FlatInternalFrameTitlePane
 		add( buttonPanel, BorderLayout.LINE_END );
 	}
 
-	private void updateFrameIcon() {
+	protected void updateFrameIcon() {
 		Icon frameIcon = frame.getFrameIcon();
-		if( frameIcon == UIManager.getIcon( "InternalFrame.icon" ) )
+		if( frameIcon != null && (frameIcon.getIconWidth() == 0 || frameIcon.getIconHeight() == 0) )
 			frameIcon = null;
+		else if( frameIcon instanceof ImageIcon )
+			frameIcon = new ScaledImageIcon( (ImageIcon) frameIcon );
 		titleLabel.setIcon( frameIcon );
 	}
 
-	private void updateColors() {
+	protected void updateColors() {
 		Color background = FlatUIUtils.nonUIResource( frame.isSelected() ? selectedTitleColor : notSelectedTitleColor );
 		Color foreground = FlatUIUtils.nonUIResource( frame.isSelected() ? selectedTextColor : notSelectedTextColor );
 
@@ -123,12 +141,25 @@ public class FlatInternalFrameTitlePane
 		closeButton.setForeground( foreground );
 	}
 
-	private void updateButtonsVisibility() {
+	protected void updateButtonsVisibility() {
 		iconButton.setVisible( frame.isIconifiable() );
 		maxButton.setVisible( frame.isMaximizable() );
 		closeButton.setVisible( frame.isClosable() );
 	}
 
+	Rectangle getFrameIconBounds() {
+		Icon icon = titleLabel.getIcon();
+		if( icon == null )
+			return null;
+
+		int iconWidth = icon.getIconWidth();
+		int iconHeight = icon.getIconHeight();
+		boolean leftToRight = titleLabel.getComponentOrientation().isLeftToRight();
+		int x = titleLabel.getX() + (leftToRight ? 0 : (titleLabel.getWidth() - iconWidth));
+		int y = titleLabel.getY() + ((titleLabel.getHeight() - iconHeight) / 2);
+		return new Rectangle( x, y, iconWidth, iconHeight );
+	}
+
 	/**
 	 * Does nothing because FlatLaf internal frames do not have system menus.
 	 */
@@ -150,7 +181,7 @@ public class FlatInternalFrameTitlePane
 
 	//---- class FlatPropertyChangeHandler ------------------------------------
 
-	private class FlatPropertyChangeHandler
+	protected class FlatPropertyChangeHandler
 		extends PropertyChangeHandler
 	{
 		@Override

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

@@ -22,10 +22,13 @@ import java.awt.Component;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.Insets;
+import java.awt.Rectangle;
+import java.awt.event.MouseEvent;
 import javax.swing.JComponent;
 import javax.swing.JInternalFrame;
 import javax.swing.LookAndFeel;
 import javax.swing.UIManager;
+import javax.swing.event.MouseInputAdapter;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicInternalFrameUI;
 
@@ -84,6 +87,8 @@ import javax.swing.plaf.basic.BasicInternalFrameUI;
 public class FlatInternalFrameUI
 	extends BasicInternalFrameUI
 {
+	protected FlatWindowResizer windowResizer;
+
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatInternalFrameUI( (JInternalFrame) c );
 	}
@@ -97,6 +102,18 @@ public class FlatInternalFrameUI
 		super.installUI( c );
 
 		LookAndFeel.installProperty( frame, "opaque", false );
+
+		windowResizer = createWindowResizer();
+	}
+
+	@Override
+	public void uninstallUI( JComponent c ) {
+		super.uninstallUI( c );
+
+		if( windowResizer != null ) {
+			windowResizer.uninstall();
+			windowResizer = null;
+		}
 	}
 
 	@Override
@@ -104,6 +121,15 @@ public class FlatInternalFrameUI
 		return new FlatInternalFrameTitlePane( w );
 	}
 
+	protected FlatWindowResizer createWindowResizer() {
+		return new FlatWindowResizer.InternalFrameResizer( frame, this::getDesktopManager );
+	}
+
+	@Override
+	protected MouseInputAdapter createBorderListener( JInternalFrame w ) {
+		return new FlatBorderListener();
+	}
+
 	//---- class FlatInternalFrameBorder --------------------------------------
 
 	public static class FlatInternalFrameBorder
@@ -112,6 +138,16 @@ public class FlatInternalFrameUI
 		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 );
+		private final boolean dropShadowPainted = UIManager.getBoolean( "InternalFrame.dropShadowPainted" );
+
+		private final FlatDropShadowBorder activeDropShadowBorder = new FlatDropShadowBorder(
+			UIManager.getColor( "InternalFrame.activeDropShadowColor" ),
+			UIManager.getInsets( "InternalFrame.activeDropShadowInsets" ),
+			FlatUIUtils.getUIFloat( "InternalFrame.activeDropShadowOpacity", 0.5f ) );
+		private final FlatDropShadowBorder inactiveDropShadowBorder = new FlatDropShadowBorder(
+			UIManager.getColor( "InternalFrame.inactiveDropShadowColor" ),
+			UIManager.getInsets( "InternalFrame.inactiveDropShadowInsets" ),
+			FlatUIUtils.getUIFloat( "InternalFrame.inactiveDropShadowOpacity", 0.5f ) );
 
 		public FlatInternalFrameBorder() {
 			super( UIManager.getInsets( "InternalFrame.borderMargins" ) );
@@ -137,19 +173,59 @@ public class FlatInternalFrameUI
 			Insets insets = getBorderInsets( c );
 			float lineWidth = scale( (float) borderLineWidth );
 
+			float rx = x + insets.left - lineWidth;
+			float ry = y + insets.top - lineWidth;
+			float rwidth = width - insets.left - insets.right + (lineWidth * 2);
+			float rheight = height - insets.top - insets.bottom + (lineWidth * 2);
+
 			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 ) );
+
+				// paint drop shadow
+				if( dropShadowPainted ) {
+					FlatDropShadowBorder dropShadowBorder = f.isSelected()
+						? activeDropShadowBorder : inactiveDropShadowBorder;
+
+					Insets dropShadowInsets = dropShadowBorder.getBorderInsets();
+					dropShadowBorder.paintBorder( c, g2,
+						(int) rx - dropShadowInsets.left,
+						(int) ry - dropShadowInsets.top,
+						(int) rwidth + dropShadowInsets.left + dropShadowInsets.right,
+						(int) rheight + dropShadowInsets.top + dropShadowInsets.bottom );
+				}
+
+				// paint border
+				g2.fill( FlatUIUtils.createRectangle( rx, ry, rwidth, rheight, lineWidth ) );
 			} finally {
 				g2.dispose();
 			}
 		}
 	}
+
+	//---- class FlatBorderListener -------------------------------------------
+
+	/**
+	 * @since 1.6
+	 */
+	protected class FlatBorderListener
+		extends BorderListener
+	{
+		@Override
+		public void mouseClicked( MouseEvent e ) {
+			if( e.getClickCount() == 2 && !frame.isIcon() &&
+				e.getSource() instanceof FlatInternalFrameTitlePane )
+			{
+				Rectangle iconBounds = ((FlatInternalFrameTitlePane)e.getSource()).getFrameIconBounds();
+				if( iconBounds != null && iconBounds.contains( e.getX(), e.getY() ) ) {
+					if( frame.isClosable() )
+						frame.doDefaultCloseAction();
+					return;
+				}
+			}
+
+			super.mouseClicked( e );
+		}
+	}
 }

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

@@ -19,8 +19,12 @@ package com.formdev.flatlaf.ui;
 import java.awt.Color;
 import java.awt.FontMetrics;
 import java.awt.Graphics;
+import java.awt.Graphics2D;
 import java.awt.Rectangle;
 import java.beans.PropertyChangeEvent;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
 import javax.swing.Icon;
 import javax.swing.JComponent;
 import javax.swing.JLabel;
@@ -30,6 +34,7 @@ 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.HiDPIUtils;
 import com.formdev.flatlaf.util.UIScale;
 
 /**
@@ -54,12 +59,8 @@ public class FlatLabelUI
 
 	private boolean defaults_initialized = false;
 
-	private static ComponentUI instance;
-
 	public static ComponentUI createUI( JComponent c ) {
-		if( instance == null )
-			instance = new FlatLabelUI();
-		return instance;
+		return FlatUIUtils.createSharedUI( FlatLabelUI.class, FlatLabelUI::new );
 	}
 
 	@Override
@@ -98,23 +99,37 @@ public class FlatLabelUI
 	}
 
 	/**
-	 * Checks whether text contains HTML headings and adds a special CSS rule to
-	 * re-calculate heading font sizes based on current component font size.
+	 * Checks whether text contains HTML tags that use "absolute-size" keywords
+	 * (e.g. "x-large") for font-size in default style sheet
+	 * (see javax/swing/text/html/default.css).
+	 * If yes, adds a special CSS rule (BASE_SIZE) to the HTML text, which
+	 * re-calculates 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" )) )
+			needsFontBaseSize( text ) )
 		{
-			int headIndex = text.indexOf( "<head>" );
-
+			// BASE_SIZE rule is parsed in javax.swing.text.html.StyleSheet.addRule()
 			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();
+			String lowerText = text.toLowerCase();
+			int headIndex;
+			int styleIndex;
+
+			int insertIndex;
+			if( (headIndex = lowerText.indexOf( "<head>" )) >= 0 ) {
+				// there is a <head> tag --> insert after <head> tag
+				insertIndex = headIndex + "<head>".length();
+			} else if( (styleIndex = lowerText.indexOf( "<style>" )) >= 0 ) {
+				// there is a <style> tag --> insert before <style> tag
+				insertIndex = styleIndex;
+			} else {
+				// no <head> or <style> tag --> insert <head> tag after <html> tag
+				style = "<head>" + style + "</head>";
+				insertIndex = "<html>".length();
+			}
+
 			text = text.substring( 0, insertIndex )
 				+ style
 				+ text.substring( insertIndex );
@@ -124,6 +139,55 @@ public class FlatLabelUI
 		BasicHTML.updateRenderer( c, text );
 	}
 
+	private static Set<String> tagsUseFontSizeSet;
+
+	private static boolean needsFontBaseSize( String text ) {
+		if( tagsUseFontSizeSet == null ) {
+			// tags that use font-size in javax/swing/text/html/default.css
+			tagsUseFontSizeSet = new HashSet<>( Arrays.asList(
+				"h1", "h2", "h3", "h4", "h5", "h6", "code", "kbd", "big", "small", "samp" ) );
+		}
+
+		// search for tags in HTML text
+		int textLength = text.length();
+		for( int i = 6; i < textLength - 1; i++ ) {
+			if( text.charAt( i ) == '<' ) {
+				switch( text.charAt( i + 1 ) ) {
+					// first letters of tags in tagsUseFontSizeSet
+					case 'b': case 'B':
+					case 'c': case 'C':
+					case 'h': case 'H':
+					case 'k': case 'K':
+					case 's': case 'S':
+						int tagBegin = i + 1;
+						for( i += 2; i < textLength; i++ ) {
+							if( !Character.isLetterOrDigit( text.charAt( i ) ) ) {
+								String tag = text.substring( tagBegin, i ).toLowerCase();
+								if( tagsUseFontSizeSet.contains( tag ) )
+									return true;
+
+								break;
+							}
+						}
+						break;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	static Graphics createGraphicsHTMLTextYCorrection( Graphics g, JComponent c ) {
+		return (c.getClientProperty( BasicHTML.propertyKey ) != null)
+			? HiDPIUtils.createGraphicsTextYCorrection( (Graphics2D) g )
+			: g;
+	}
+
+	@Override
+	public void paint( Graphics g, JComponent c ) {
+		super.paint( createGraphicsHTMLTextYCorrection( g, c ), c );
+	}
+
 	@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

@@ -48,6 +48,14 @@ public class FlatLineBorder
 		this.lineThickness = lineThickness;
 	}
 
+	public Color getLineColor() {
+		return lineColor;
+	}
+
+	public float getLineThickness() {
+		return lineThickness;
+	}
+
 	@Override
 	public void paintBorder( Component c, Graphics g, int x, int y, int width, int height ) {
 		Graphics2D g2 = (Graphics2D) g.create();

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

@@ -17,12 +17,15 @@
 package com.formdev.flatlaf.ui;
 
 import java.awt.Color;
+import java.awt.EventQueue;
 import java.awt.event.FocusEvent;
 import java.awt.event.FocusListener;
+import java.beans.PropertyChangeListener;
 import javax.swing.JComponent;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicListUI;
+import com.formdev.flatlaf.FlatClientProperties;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JList}.
@@ -81,7 +84,7 @@ public class FlatListUI
 		selectionInactiveBackground = UIManager.getColor( "List.selectionInactiveBackground" );
 		selectionInactiveForeground = UIManager.getColor( "List.selectionInactiveForeground" );
 
-		toggleSelectionColors( list.hasFocus() );
+		toggleSelectionColors();
 	}
 
 	@Override
@@ -94,19 +97,34 @@ public class FlatListUI
 		selectionInactiveForeground = null;
 	}
 
+	@Override
+	protected PropertyChangeListener createPropertyChangeListener() {
+		PropertyChangeListener superListener = super.createPropertyChangeListener();
+		return e -> {
+			superListener.propertyChange( e );
+
+			if( FlatClientProperties.COMPONENT_FOCUS_OWNER.equals( e.getPropertyName() ) )
+				toggleSelectionColors();
+		};
+	}
+
 	@Override
 	protected FocusListener createFocusListener() {
 		return new BasicListUI.FocusHandler() {
 			@Override
 			public void focusGained( FocusEvent e ) {
 				super.focusGained( e );
-				toggleSelectionColors( true );
+				toggleSelectionColors();
 			}
 
 			@Override
 			public void focusLost( FocusEvent e ) {
 				super.focusLost( e );
-				toggleSelectionColors( false );
+
+				// use invokeLater for the case that the window is deactivated
+				EventQueue.invokeLater( () -> {
+					toggleSelectionColors();
+				} );
 			}
 		};
 	}
@@ -120,8 +138,11 @@ 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( list == null )
+			return;
+
+		if( FlatUIUtils.isPermanentFocusOwner( list ) ) {
 			if( list.getSelectionBackground() == selectionInactiveBackground )
 				list.setSelectionBackground( selectionBackground );
 			if( list.getSelectionForeground() == selectionInactiveForeground )

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

@@ -20,9 +20,7 @@ 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 java.awt.geom.Rectangle2D;
 import javax.swing.JMenuBar;
 import javax.swing.UIManager;
 
@@ -40,16 +38,8 @@ public class FlatMenuBarBorder
 
 	@Override
 	public void paintBorder( Component c, Graphics g, int x, int y, int width, int height ) {
-		Graphics2D g2 = (Graphics2D) g.create();
-		try {
-			float lineHeight = scale( (float) 1 );
-
-			FlatUIUtils.setRenderingHints( g2 );
-			g2.setColor( borderColor );
-			g2.fill( new Rectangle2D.Float( x, y + height - lineHeight, width, lineHeight ) );
-		} finally {
-			g2.dispose();
-		}
+		float lineHeight = scale( (float) 1 );
+		FlatUIUtils.paintFilledRectangle( g, borderColor, x, y + height - lineHeight, width, lineHeight );
 	}
 
 	@Override

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

@@ -16,9 +16,27 @@
 
 package com.formdev.flatlaf.ui;
 
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Window;
+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.JRootPane;
+import javax.swing.LookAndFeel;
+import javax.swing.MenuElement;
+import javax.swing.MenuSelectionManager;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.plaf.ActionMapUIResource;
 import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.UIResource;
 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}.
@@ -29,6 +47,7 @@ import javax.swing.plaf.basic.BasicMenuBarUI;
  * @uiDefault MenuBar.background						Color
  * @uiDefault MenuBar.foreground						Color
  * @uiDefault MenuBar.border							Border
+ * @uiDefault TitlePane.unifiedBackground				boolean
  *
  * @author Karl Tauber
  */
@@ -38,4 +57,90 @@ 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 installDefaults() {
+		super.installDefaults();
+
+		LookAndFeel.installProperty( menuBar, "opaque", false );
+	}
+
+	@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() );
+	}
+
+	@Override
+	public void update( Graphics g, JComponent c ) {
+		// paint background
+		Color background = getBackground( c );
+		if( background != null ) {
+			g.setColor( background );
+			g.fillRect( 0, 0, c.getWidth(), c.getHeight() );
+		}
+
+		paint( g, c );
+	}
+
+	protected Color getBackground( JComponent c ) {
+		Color background = c.getBackground();
+
+		// paint background if opaque or if having custom background color
+		if( c.isOpaque() || !(background instanceof UIResource) )
+			return background;
+
+		// paint background if menu bar is not the "main" menu bar
+		JRootPane rootPane = SwingUtilities.getRootPane( c );
+		if( rootPane == null || !(rootPane.getParent() instanceof Window) || rootPane.getJMenuBar() != c )
+			return background;
+
+		// use parent background for unified title pane
+		// (not storing value of "TitlePane.unifiedBackground" in class to allow changing at runtime)
+		if( UIManager.getBoolean( "TitlePane.unifiedBackground" ) &&
+			FlatNativeWindowBorder.hasCustomDecoration( (Window) rootPane.getParent() ) )
+		  background = FlatUIUtils.getParentBackground( c );
+
+		// paint background in full screen mode
+		if( FlatUIUtils.isFullScreen( rootPane ) )
+			return background;
+
+		// do not paint background if menu bar is embedded into title pane
+		return FlatRootPaneUI.isMenuBarEmbedded( rootPane ) ? null : background;
+	}
+
+	//---- 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.isWindows
+					? new MenuElement[] { menuBar, menu }
+					: new MenuElement[] { menuBar, menu, menu.getPopupMenu() } );
+
+				FlatLaf.showMnemonics( menuBar );
+			}
+		}
+	}
 }

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

@@ -40,7 +40,7 @@ public class FlatMenuItemBorder
 		if( c.getParent() instanceof JMenuBar ) {
 			insets.top = scale( menuBarItemMargins.top );
 			insets.left = scale( menuBarItemMargins.left );
-			insets.bottom = scale( menuBarItemMargins.bottom + 1 );
+			insets.bottom = scale( menuBarItemMargins.bottom );
 			insets.right = scale( menuBarItemMargins.right );
 			return insets;
 		} else

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

@@ -0,0 +1,581 @@
+/*
+ * 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.DerivedColor;
+import com.formdev.flatlaf.util.Graphics2DProxy;
+import com.formdev.flatlaf.util.HiDPIUtils;
+import com.formdev.flatlaf.util.SystemInfo;
+
+/**
+ * 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						int
+ * @uiDefault MenuItem.selectionBackground							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 final Color selectionBackground = UIManager.getColor( "MenuItem.selectionBackground" );
+
+	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*/
+
+		boolean underlineSelection = isUnderlineSelection();
+		paintBackground( g, underlineSelection ? underlineSelectionBackground : selectionBackground );
+		if( underlineSelection && isArmedOrSelected( menuItem ) )
+			paintUnderlineSelection( g, underlineSelectionColor, underlineSelectionHeight );
+		paintIcon( g, iconRect, getIconForPainting(), underlineSelection ? underlineSelectionCheckBackground : checkBackground );
+		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 ) {
+			// paint background
+			g.setColor( armedOrSelected
+				? deriveBackground( selectionBackground )
+				: menuItem.getBackground() );
+			g.fillRect( 0, 0, menuItem.getWidth(), menuItem.getHeight() );
+		}
+	}
+
+	protected void paintUnderlineSelection( Graphics g, Color underlineSelectionColor, int underlineSelectionHeight ) {
+		int width = menuItem.getWidth();
+		int height = menuItem.getHeight();
+
+		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 Color deriveBackground( Color background ) {
+		if( !(background instanceof DerivedColor) )
+			return background;
+
+		Color baseColor = menuItem.isOpaque()
+			? menuItem.getBackground()
+			: FlatUIUtils.getParentBackground( menuItem );
+
+		return FlatUIUtils.deriveColor( background, baseColor );
+	}
+
+	protected void paintIcon( Graphics g, Rectangle iconRect, Icon icon, Color checkBackground ) {
+		// 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( FlatUIUtils.deriveColor( checkBackground, selectionBackground ) );
+			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 = (isTopLevelMenu( menuItem ) ? menuItem.getParent() : 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( HiDPIUtils.createGraphicsTextYCorrection( (Graphics2D) 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();
+	}
+
+	protected 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 boolean cachedAcceleratorLeftToRight;
+
+	private String getAcceleratorText() {
+		KeyStroke accelerator = menuItem.getAccelerator();
+		if( accelerator == null )
+			return null;
+
+		boolean leftToRight = menuItem.getComponentOrientation().isLeftToRight();
+
+		if( accelerator == cachedAccelerator && leftToRight == cachedAcceleratorLeftToRight )
+			return cachedAcceleratorText;
+
+		cachedAccelerator = accelerator;
+		cachedAcceleratorText = getTextForAccelerator( accelerator );
+		cachedAcceleratorLeftToRight = leftToRight;
+
+		return cachedAcceleratorText;
+	}
+
+	protected String getTextForAccelerator( KeyStroke accelerator ) {
+		StringBuilder buf = new StringBuilder();
+		boolean leftToRight = menuItem.getComponentOrientation().isLeftToRight();
+
+		// modifiers
+		int modifiers = accelerator.getModifiers();
+		if( modifiers != 0 ) {
+			if( SystemInfo.isMacOS ) {
+				if( leftToRight )
+					buf.append( getMacOSModifiersExText( modifiers, leftToRight ) );
+			} else
+				buf.append( InputEvent.getModifiersExText( modifiers ) ).append( acceleratorDelimiter );
+		}
+
+		// key
+		int keyCode = accelerator.getKeyCode();
+		if( keyCode != 0 )
+			buf.append( KeyEvent.getKeyText( keyCode ) );
+		else
+			buf.append( accelerator.getKeyChar() );
+
+		// modifiers if right-to-left on macOS
+		if( modifiers != 0 && !leftToRight && SystemInfo.isMacOS )
+			buf.append( getMacOSModifiersExText( modifiers, leftToRight ) );
+
+		return buf.toString();
+	}
+
+	protected String getMacOSModifiersExText( int modifiers, boolean leftToRight ) {
+		StringBuilder buf = new StringBuilder();
+
+		if( (modifiers & InputEvent.CTRL_DOWN_MASK) != 0 )
+			buf.append( controlGlyph );
+		if( (modifiers & (InputEvent.ALT_DOWN_MASK | InputEvent.ALT_GRAPH_DOWN_MASK)) != 0 )
+			buf.append( optionGlyph );
+		if( (modifiers & InputEvent.SHIFT_DOWN_MASK) != 0 )
+			buf.append( shiftGlyph );
+		if( (modifiers & InputEvent.META_DOWN_MASK) != 0 )
+			buf.append( commandGlyph );
+
+		// reverse order for right-to-left
+		if( !leftToRight )
+			buf.reverse();
+
+		return buf.toString();
+	}
+
+	private static final char
+		controlGlyph = 0x2303,
+		optionGlyph = 0x2325,
+		shiftGlyph = 0x21E7,
+		commandGlyph = 0x2318;
+
+	//---- 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,48 +16,47 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
-import java.awt.Color;
-import java.awt.FontMetrics;
+import java.awt.Dimension;
 import java.awt.Graphics;
-import java.awt.Rectangle;
-import java.beans.PropertyChangeListener;
-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.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicMenuItemUI;
-import com.formdev.flatlaf.FlatLaf;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JMenuItem}.
  *
  * <!-- 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();
 	}
@@ -66,42 +65,30 @@ public class FlatMenuItemUI
 	protected void installDefaults() {
 		super.installDefaults();
 
-		// scale
-		defaultTextIconGap = scale( defaultTextIconGap );
-	}
+		LookAndFeel.installProperty( menuItem, "iconTextGap", FlatUIUtils.getUIInt( "MenuItem.iconTextGap", 4 ) );
 
-	/**
-	 * 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 );
-		};
+		renderer = createRenderer();
 	}
 
 	@Override
-	protected void paintText( Graphics g, JMenuItem menuItem, Rectangle textRect, String text ) {
-		paintText( g, menuItem, textRect, text, disabledForeground, selectionForeground );
+	protected void uninstallDefaults() {
+		super.uninstallDefaults();
+
+		renderer = null;
 	}
 
-	public static void paintText( Graphics g, JMenuItem menuItem, Rectangle textRect,
-		String text, Color disabledForeground, Color selectionForeground )
-	{
-		FontMetrics fm = menuItem.getFontMetrics( menuItem.getFont() );
-		int mnemonicIndex = FlatLaf.isShowMnemonics() ? menuItem.getDisplayedMnemonicIndex() : -1;
+	protected FlatMenuItemRenderer createRenderer() {
+		return new FlatMenuItemRenderer( menuItem, checkIcon, arrowIcon, acceleratorFont, acceleratorDelimiter );
+	}
 
-		ButtonModel model = menuItem.getModel();
-		g.setColor( !model.isEnabled()
-			? disabledForeground
-			: (model.isArmed() || (menuItem instanceof JMenu && model.isSelected())
-				? selectionForeground
-				: menuItem.getForeground()) );
+	@Override
+	protected Dimension getPreferredMenuItemSize( JComponent c, Icon checkIcon, Icon arrowIcon, int defaultTextIconGap ) {
+		return renderer.getPreferredMenuItemSize();
+	}
 
-		FlatUIUtils.drawStringUnderlineCharAt( menuItem, g, text, mnemonicIndex,
-			textRect.x, textRect.y + fm.getAscent() );
+	@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,16 +16,17 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
 import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Font;
 import java.awt.Graphics;
-import java.awt.Rectangle;
 import java.awt.event.MouseEvent;
-import java.beans.PropertyChangeListener;
 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;
@@ -36,30 +37,36 @@ 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 MenuBar.hoverBackground				Color
+ * @uiDefault MenuItem.iconTextGap									int
+ * @uiDefault MenuBar.hoverBackground								Color
+ *
+ * <!-- FlatMenuRenderer -->
+ *
+ * @uiDefault MenuBar.underlineSelectionBackground					Color
+ * @uiDefault MenuBar.underlineSelectionColor						Color
+ * @uiDefault MenuBar.underlineSelectionHeight						int
  *
  * @author Karl Tauber
  */
@@ -67,6 +74,7 @@ public class FlatMenuUI
 	extends BasicMenuUI
 {
 	private Color hoverBackground;
+	private FlatMenuItemRenderer renderer;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatMenuUI();
@@ -76,12 +84,12 @@ public class FlatMenuUI
 	protected void installDefaults() {
 		super.installDefaults();
 
+		LookAndFeel.installProperty( menuItem, "iconTextGap", FlatUIUtils.getUIInt( "MenuItem.iconTextGap", 4 ) );
+
 		menuItem.setRolloverEnabled( true );
 
 		hoverBackground = UIManager.getColor( "MenuBar.hoverBackground" );
-
-		// scale
-		defaultTextIconGap = scale( defaultTextIconGap );
+		renderer = createRenderer();
 	}
 
 	@Override
@@ -89,19 +97,11 @@ public class FlatMenuUI
 		super.uninstallDefaults();
 
 		hoverBackground = null;
+		renderer = null;
 	}
 
-	/**
-	 * 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 FlatMenuItemRenderer createRenderer() {
+		return new FlatMenuRenderer( menuItem, checkIcon, arrowIcon, acceleratorFont, acceleratorDelimiter );
 	}
 
 	@Override
@@ -130,19 +130,62 @@ public class FlatMenuUI
 	}
 
 	@Override
-	protected void paintBackground( Graphics g, JMenuItem menuItem, Color bgColor ) {
-		ButtonModel model = menuItem.getModel();
-		if( model.isArmed() || model.isSelected() ) {
-			super.paintBackground( g, menuItem, bgColor );
-		} else if( model.isRollover() && model.isEnabled() && ((JMenu)menuItem).isTopLevelMenu() ) {
-			FlatUIUtils.setColor( g, hoverBackground, menuItem.getBackground() );
-			g.fillRect( 0, 0, menuItem.getWidth(), menuItem.getHeight() );
-		} else
-			super.paintBackground( g, menuItem, bgColor );
+	public Dimension getMinimumSize( JComponent c ) {
+		// avoid that top-level menus (in menu bar) are made smaller if horizontal space is rare
+		// same code is in BasicMenuUI since Java 10
+		// see https://bugs.openjdk.java.net/browse/JDK-8178430
+		return ((JMenu)menuItem).isTopLevelMenu() ? c.getPreferredSize() : null;
 	}
 
 	@Override
-	protected void paintText( Graphics g, JMenuItem menuItem, Rectangle textRect, String text ) {
-		FlatMenuItemUI.paintText( g, menuItem, textRect, text, disabledForeground, selectionForeground );
+	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 final Color menuBarUnderlineSelectionBackground = FlatUIUtils.getUIColor( "MenuBar.underlineSelectionBackground", underlineSelectionBackground );
+		protected final Color menuBarUnderlineSelectionColor = FlatUIUtils.getUIColor( "MenuBar.underlineSelectionColor", underlineSelectionColor );
+		protected final int menuBarUnderlineSelectionHeight = FlatUIUtils.getUIInt( "MenuBar.underlineSelectionHeight", underlineSelectionHeight );
+
+		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 ) {
+			if( isUnderlineSelection() && ((JMenu)menuItem).isTopLevelMenu() )
+				selectionBackground = menuBarUnderlineSelectionBackground;
+
+			ButtonModel model = menuItem.getModel();
+			if( model.isRollover() && !model.isArmed() && !model.isSelected() &&
+				model.isEnabled() && ((JMenu)menuItem).isTopLevelMenu() )
+			{
+				g.setColor( deriveBackground( hoverBackground ) );
+				g.fillRect( 0, 0, menuItem.getWidth(), menuItem.getHeight() );
+			} else
+				super.paintBackground( g, selectionBackground );
+		}
+
+		@Override
+		protected void paintUnderlineSelection( Graphics g, Color underlineSelectionColor, int underlineSelectionHeight ) {
+			if( ((JMenu)menuItem).isTopLevelMenu() ) {
+				underlineSelectionColor = menuBarUnderlineSelectionColor;
+				underlineSelectionHeight = menuBarUnderlineSelectionHeight;
+			}
+
+			super.paintUnderlineSelection( g, underlineSelectionColor, underlineSelectionHeight );
+		}
 	}
 }

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

@@ -0,0 +1,360 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.ui;
+
+import java.awt.Color;
+import java.awt.Container;
+import java.awt.Rectangle;
+import java.awt.Window;
+import java.beans.PropertyChangeListener;
+import java.util.List;
+import javax.swing.JDialog;
+import javax.swing.JFrame;
+import javax.swing.JRootPane;
+import javax.swing.UIManager;
+import javax.swing.event.ChangeListener;
+import com.formdev.flatlaf.FlatClientProperties;
+import com.formdev.flatlaf.FlatLaf;
+import com.formdev.flatlaf.FlatSystemProperties;
+import com.formdev.flatlaf.ui.JBRCustomDecorations.JBRWindowTopBorder;
+import com.formdev.flatlaf.util.SystemInfo;
+
+/**
+ * Support for custom window decorations with native window border.
+ *
+ * @author Karl Tauber
+ * @since 1.1
+ */
+public class FlatNativeWindowBorder
+{
+	// can use window decorations if:
+	// - on Windows 10
+	// - not when running in JetBrains Projector, Webswing or WinPE
+	// - not disabled via system property
+	private static final boolean canUseWindowDecorations =
+		SystemInfo.isWindows_10_orLater &&
+		!SystemInfo.isProjector &&
+		!SystemInfo.isWebswing &&
+		!SystemInfo.isWinPE &&
+		FlatSystemProperties.getBoolean( FlatSystemProperties.USE_WINDOW_DECORATIONS, true );
+
+	// check this field before using class JBRCustomDecorations to avoid unnecessary loading of that class
+	private static final boolean canUseJBRCustomDecorations =
+		canUseWindowDecorations &&
+		SystemInfo.isJetBrainsJVM_11_orLater &&
+		FlatSystemProperties.getBoolean( FlatSystemProperties.USE_JETBRAINS_CUSTOM_DECORATIONS, true );
+
+	private static Boolean supported;
+	private static Provider nativeProvider;
+
+	public static boolean isSupported() {
+		if( canUseJBRCustomDecorations )
+			return JBRCustomDecorations.isSupported();
+
+		initialize();
+		return supported;
+	}
+
+	static Object install( JRootPane rootPane ) {
+		if( canUseJBRCustomDecorations )
+			return JBRCustomDecorations.install( rootPane );
+
+		if( !isSupported() )
+			return null;
+
+		// do nothing if root pane has a parent that is not a window (e.g. a JInternalFrame)
+		Container parent = rootPane.getParent();
+		if( parent != null && !(parent instanceof Window) )
+			return null;
+
+		// Check whether root pane already has a window, which is the case when
+		// switching from another LaF to FlatLaf.
+		// Also check whether the window is displayable, which is required to install
+		// FlatLaf native window border.
+		// If the window is not displayable, then it was probably closed/disposed but not yet removed
+		// from the list of windows that AWT maintains and returns with Window.getWindows().
+		// It could be also be a window that is currently hidden, but may be shown later.
+		if( parent instanceof Window && parent.isDisplayable() )
+			install( (Window) parent );
+
+		// Install FlatLaf native window border, which must be done late,
+		// when the native window is already created, because it needs access to the window.
+		// Uninstall FlatLaf native window border when window is disposed (or root pane removed).
+		// "ancestor" property change event is fired from JComponent.addNotify() and removeNotify().
+		PropertyChangeListener ancestorListener = e -> {
+			Object newValue = e.getNewValue();
+			if( newValue instanceof Window )
+				install( (Window) newValue );
+			else if( newValue == null && e.getOldValue() instanceof Window )
+				uninstall( (Window) e.getOldValue() );
+		};
+		rootPane.addPropertyChangeListener( "ancestor", ancestorListener );
+		return ancestorListener;
+	}
+
+	static void install( Window window ) {
+		if( hasCustomDecoration( window ) )
+			return;
+
+		// do not enable native window border if LaF provides decorations
+		if( UIManager.getLookAndFeel().getSupportsWindowDecorations() )
+			return;
+
+		if( window instanceof JFrame ) {
+			JFrame frame = (JFrame) window;
+			JRootPane rootPane = frame.getRootPane();
+
+			// check whether disabled via system property, client property or UI default
+			if( !useWindowDecorations( rootPane ) )
+				return;
+
+			// do not enable native window border if frame is undecorated
+			if( frame.isUndecorated() )
+				return;
+
+			// enable native window border for window
+			setHasCustomDecoration( frame, true );
+
+			// avoid double window title bar if enabling native window border failed
+			if( !hasCustomDecoration( frame ) )
+				return;
+
+			// enable Swing window decoration
+			rootPane.setWindowDecorationStyle( JRootPane.FRAME );
+
+		} else if( window instanceof JDialog ) {
+			JDialog dialog = (JDialog) window;
+			JRootPane rootPane = dialog.getRootPane();
+
+			// check whether disabled via system property, client property or UI default
+			if( !useWindowDecorations( rootPane ) )
+				return;
+
+			// do not enable native window border if dialog is undecorated
+			if( dialog.isUndecorated() )
+				return;
+
+			// enable native window border for window
+			setHasCustomDecoration( dialog, true );
+
+			// avoid double window title bar if enabling native window border failed
+			if( !hasCustomDecoration( dialog ) )
+				return;
+
+			// enable Swing window decoration
+			rootPane.setWindowDecorationStyle( JRootPane.PLAIN_DIALOG );
+		}
+	}
+
+	static void uninstall( JRootPane rootPane, Object data ) {
+		if( canUseJBRCustomDecorations ) {
+			JBRCustomDecorations.uninstall( rootPane, data );
+			return;
+		}
+
+		if( !isSupported() )
+			return;
+
+		// remove listener
+		if( data instanceof PropertyChangeListener )
+			rootPane.removePropertyChangeListener( "ancestor", (PropertyChangeListener) data );
+
+		// do not uninstall when switching to another FlatLaf theme and if still enabled
+		if( UIManager.getLookAndFeel() instanceof FlatLaf && useWindowDecorations( rootPane ) )
+			return;
+
+		// uninstall native window border
+		Container parent = rootPane.getParent();
+		if( parent instanceof Window )
+			uninstall( (Window) parent );
+	}
+
+	private static void uninstall( Window window ) {
+		if( !hasCustomDecoration( window ) )
+			return;
+
+		// disable native window border for window
+		setHasCustomDecoration( window, false );
+
+		if( window instanceof JFrame ) {
+			JFrame frame = (JFrame) window;
+
+			// disable Swing window decoration
+			frame.getRootPane().setWindowDecorationStyle( JRootPane.NONE );
+
+		} else if( window instanceof JDialog ) {
+			JDialog dialog = (JDialog) window;
+
+			// disable Swing window decoration
+			dialog.getRootPane().setWindowDecorationStyle( JRootPane.NONE );
+		}
+	}
+
+	private static boolean useWindowDecorations( JRootPane rootPane ) {
+		return FlatUIUtils.getBoolean( rootPane,
+			FlatSystemProperties.USE_WINDOW_DECORATIONS,
+			FlatClientProperties.USE_WINDOW_DECORATIONS,
+			"TitlePane.useWindowDecorations",
+			false );
+	}
+
+	public static boolean hasCustomDecoration( Window window ) {
+		if( canUseJBRCustomDecorations )
+			return JBRCustomDecorations.hasCustomDecoration( window );
+
+		if( !isSupported() )
+			return false;
+
+		return nativeProvider.hasCustomDecoration( window );
+	}
+
+	public static void setHasCustomDecoration( Window window, boolean hasCustomDecoration ) {
+		if( canUseJBRCustomDecorations ) {
+			JBRCustomDecorations.setHasCustomDecoration( window, hasCustomDecoration );
+			return;
+		}
+
+		if( !isSupported() )
+			return;
+
+		nativeProvider.setHasCustomDecoration( window, hasCustomDecoration );
+	}
+
+	static void setTitleBarHeightAndHitTestSpots( Window window, int titleBarHeight,
+		List<Rectangle> hitTestSpots, Rectangle appIconBounds )
+	{
+		if( canUseJBRCustomDecorations ) {
+			JBRCustomDecorations.setTitleBarHeightAndHitTestSpots( window, titleBarHeight, hitTestSpots );
+			return;
+		}
+
+		if( !isSupported() )
+			return;
+
+		nativeProvider.setTitleBarHeight( window, titleBarHeight );
+		nativeProvider.setTitleBarHitTestSpots( window, hitTestSpots );
+		nativeProvider.setTitleBarAppIconBounds( window, appIconBounds );
+	}
+
+	static boolean showWindow( Window window, int cmd ) {
+		if( canUseJBRCustomDecorations || !isSupported() )
+			return false;
+
+		return nativeProvider.showWindow( window, cmd );
+	}
+
+	private static void initialize() {
+		if( supported != null )
+			return;
+		supported = false;
+
+		if( !canUseWindowDecorations )
+			return;
+
+		try {
+/*
+			Class<?> cls = Class.forName( "com.formdev.flatlaf.natives.jna.windows.FlatWindowsNativeWindowBorder" );
+			Method m = cls.getMethod( "getInstance" );
+			setNativeProvider( (Provider) m.invoke( null ) );
+*/
+			setNativeProvider( FlatWindowsNativeWindowBorder.getInstance() );
+		} catch( Exception ex ) {
+			// ignore
+		}
+	}
+
+	/**
+	 * @since 1.1.1
+	 */
+	public static void setNativeProvider( Provider provider ) {
+		if( nativeProvider != null )
+			throw new IllegalStateException();
+
+		nativeProvider = provider;
+		supported = (nativeProvider != null);
+	}
+
+	//---- interface Provider -------------------------------------------------
+
+	public interface Provider
+	{
+		boolean hasCustomDecoration( Window window );
+		void setHasCustomDecoration( Window window, boolean hasCustomDecoration );
+		void setTitleBarHeight( Window window, int titleBarHeight );
+		void setTitleBarHitTestSpots( Window window, List<Rectangle> hitTestSpots );
+		void setTitleBarAppIconBounds( Window window, Rectangle appIconBounds );
+
+		// commands for showWindow(); values must match Win32 API
+		// https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-showwindow
+		int SW_MAXIMIZE = 3;
+		int SW_MINIMIZE = 6;
+		int SW_RESTORE = 9;
+		boolean showWindow( Window window, int cmd );
+
+		boolean isColorizationColorAffectsBorders();
+		Color getColorizationColor();
+		int getColorizationColorBalance();
+
+		void addChangeListener( ChangeListener l );
+		void removeChangeListener( ChangeListener l );
+	}
+
+	//---- class WindowTopBorder -------------------------------------------
+
+	static class WindowTopBorder
+		extends JBRCustomDecorations.JBRWindowTopBorder
+	{
+		private static WindowTopBorder instance;
+
+		static JBRWindowTopBorder getInstance() {
+			if( canUseJBRCustomDecorations )
+				return JBRWindowTopBorder.getInstance();
+
+			if( instance == null )
+				instance = new WindowTopBorder();
+			return instance;
+		}
+
+		@Override
+		void installListeners() {
+			nativeProvider.addChangeListener( e -> {
+				update();
+
+				// repaint top borders of all windows
+				for( Window window : Window.getWindows() ) {
+					if( window.isDisplayable() )
+						window.repaint( 0, 0, window.getWidth(), 1 );
+				}
+			} );
+		}
+
+		@Override
+		boolean isColorizationColorAffectsBorders() {
+			return nativeProvider.isColorizationColorAffectsBorders();
+		}
+
+		@Override
+		Color getColorizationColor() {
+			return nativeProvider.getColorizationColor();
+		}
+
+		@Override
+		int getColorizationColorBalance() {
+			return nativeProvider.getColorizationColorBalance();
+		}
+	}
+}

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

@@ -22,7 +22,11 @@ import java.awt.Dimension;
 import java.awt.Graphics;
 import java.awt.GridBagConstraints;
 import java.awt.Insets;
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.Icon;
 import javax.swing.JComponent;
+import javax.swing.JLabel;
 import javax.swing.JPanel;
 import javax.swing.UIManager;
 import javax.swing.border.Border;
@@ -88,6 +92,7 @@ public class FlatOptionPaneUI
 	protected int messagePadding;
 	protected int maxCharactersPerLine;
 	private int focusWidth;
+	private boolean sameSizeButtons;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatOptionPaneUI();
@@ -101,6 +106,7 @@ public class FlatOptionPaneUI
 		messagePadding = UIManager.getInt( "OptionPane.messagePadding" );
 		maxCharactersPerLine = UIManager.getInt( "OptionPane.maxCharactersPerLine" );
 		focusWidth = UIManager.getInt( "Component.focusWidth" );
+		sameSizeButtons = FlatUIUtils.getUIBoolean( "OptionPane.sameSizeButtons", true );
 	}
 
 	@Override
@@ -157,15 +163,40 @@ public class FlatOptionPaneUI
 			cons.insets.bottom = UIScale.scale( messagePadding );
 
 		// disable line wrapping for HTML
-		if( msg instanceof String && BasicHTML.isHTMLString( (String) msg ) )
-			maxll = Integer.MAX_VALUE;
+		if( msg != null &&
+			!(msg instanceof Component) &&
+			!(msg instanceof Object[]) &&
+			!(msg instanceof Icon) )
+		{
+			msg = msg.toString();
+			if( BasicHTML.isHTMLString( (String) msg ) )
+				maxll = Integer.MAX_VALUE;
+		}
+
+		// fix right-to-left alignment if super.addMessageComponents() breaks longer lines
+		// into multiple labels and puts them into a box that aligns them to the left
+		if( msg instanceof Box ) {
+			Box box = (Box) msg;
+			if( "OptionPane.verticalBox".equals( box.getName() ) &&
+				box.getLayout() instanceof BoxLayout &&
+				((BoxLayout)box.getLayout()).getAxis() == BoxLayout.Y_AXIS )
+			{
+				box.addPropertyChangeListener( "componentOrientation", e -> {
+					float alignX = box.getComponentOrientation().isLeftToRight() ? 0 : 1;
+					for( Component c : box.getComponents() ) {
+						if( c instanceof JLabel && "OptionPane.label".equals( c.getName() ) )
+							((JLabel)c).setAlignmentX( alignX );
+					}
+				} );
+			}
+		}
 
 		super.addMessageComponents( container, cons, msg, maxll, internallyCreated );
 	}
 
 	private void updateChildPanels( Container c ) {
 		for( Component child : c.getComponents() ) {
-			if( child instanceof JPanel ) {
+			if( child.getClass() == JPanel.class ) {
 				JPanel panel = (JPanel)child;
 
 				// make sub-panel non-opaque for OptionPane.background
@@ -177,9 +208,8 @@ public class FlatOptionPaneUI
 					panel.setBorder( new NonUIResourceBorder( border ) );
 			}
 
-			if( child instanceof Container ) {
+			if( child instanceof Container )
 				updateChildPanels( (Container) child );
-			}
 		}
 	}
 
@@ -197,6 +227,11 @@ public class FlatOptionPaneUI
 		return null;
 	}
 
+	@Override
+	protected boolean getSizeButtonsToSameWidth() {
+		return sameSizeButtons;
+	}
+
 	//---- class NonUIResourceBorder ------------------------------------------
 
 	private static class NonUIResourceBorder

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

@@ -35,11 +35,7 @@ import javax.swing.plaf.basic.BasicPanelUI;
 public class FlatPanelUI
 	extends BasicPanelUI
 {
-	private static ComponentUI instance;
-
 	public static ComponentUI createUI( JComponent c ) {
-		if( instance == null )
-			instance = new FlatPanelUI();
-		return instance;
+		return FlatUIUtils.createSharedUI( FlatPanelUI.class, FlatPanelUI::new );
 	}
 }

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

@@ -16,30 +16,31 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
-import java.awt.Color;
-import java.awt.Dimension;
 import java.awt.Graphics;
+import java.awt.Insets;
+import java.awt.Shape;
 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.Action;
+import javax.swing.ActionMap;
 import javax.swing.Icon;
 import javax.swing.JComponent;
 import javax.swing.LookAndFeel;
+import javax.swing.SwingUtilities;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
-import javax.swing.plaf.basic.BasicPasswordFieldUI;
-import javax.swing.text.Caret;
+import javax.swing.text.DefaultEditorKit;
+import javax.swing.text.Element;
 import javax.swing.text.JTextComponent;
-import com.formdev.flatlaf.FlatClientProperties;
+import javax.swing.text.PasswordView;
+import javax.swing.text.View;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JPasswordField}.
  *
- * <!-- BasicPasswordFieldUI -->
+ * <!-- BasicTextFieldUI -->
  *
  * @uiDefault PasswordField.font					Font
  * @uiDefault PasswordField.background				Color
@@ -52,70 +53,67 @@ import com.formdev.flatlaf.FlatClientProperties;
  * @uiDefault PasswordField.inactiveForeground		Color	used if not enabled (yes, this is confusing; this should be named disabledForeground)
  * @uiDefault PasswordField.border					Border
  * @uiDefault PasswordField.margin					Insets
- * @uiDefault PasswordField.echoChar				character
  * @uiDefault PasswordField.caretBlinkRate			int		default is 500 milliseconds
  *
- * <!-- FlatPasswordFieldUI -->
+ * <!-- FlatTextFieldUI -->
  *
- * @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 PasswordField.focusedBackground		Color	optional
  * @uiDefault TextComponent.selectAllOnFocusPolicy	String	never, once (default) or always
+ * @uiDefault TextComponent.selectAllOnMouseClick	boolean
+ *
+ * <!-- FlatPasswordFieldUI -->
+ *
+ * @uiDefault PasswordField.echoChar				character
+ * @uiDefault PasswordField.showCapsLock			boolean
+ * @uiDefault PasswordField.capsLockIcon			Icon
  *
  * @author Karl Tauber
  */
 public class FlatPasswordFieldUI
-	extends BasicPasswordFieldUI
+	extends FlatTextFieldUI
 {
-	protected int arc;
-	protected int focusWidth;
-	protected int minimumWidth;
-	protected boolean isIntelliJTheme;
-	protected Color placeholderForeground;
+	protected boolean showCapsLock;
 	protected Icon capsLockIcon;
 
-	private FocusListener focusListener;
 	private KeyListener capsLockListener;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatPasswordFieldUI();
 	}
 
+	@Override
+	protected String getPropertyPrefix() {
+		return "PasswordField";
+	}
+
 	@Override
 	protected void installDefaults() {
 		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" );
-		placeholderForeground = UIManager.getColor( prefix + ".placeholderForeground" );
+		Character echoChar = (Character) UIManager.get( prefix + ".echoChar" );
+		if( echoChar != null )
+			LookAndFeel.installProperty( getComponent(), "echoChar", echoChar );
+
+		showCapsLock = UIManager.getBoolean( "PasswordField.showCapsLock" );
 		capsLockIcon = UIManager.getIcon( "PasswordField.capsLockIcon" );
-
-		LookAndFeel.installProperty( getComponent(), "opaque", focusWidth == 0 );
-
-		MigLayoutVisualPadding.install( getComponent(), focusWidth );
 	}
 
 	@Override
 	protected void uninstallDefaults() {
 		super.uninstallDefaults();
 
-		placeholderForeground = null;
 		capsLockIcon = null;
-
-		MigLayoutVisualPadding.uninstall( getComponent() );
 	}
 
 	@Override
 	protected void installListeners() {
 		super.installListeners();
 
-		focusListener = new FlatUIUtils.RepaintFocusListener( getComponent() );
+		// update caps lock indicator
 		capsLockListener = new KeyAdapter() {
 			@Override
 			public void keyPressed( KeyEvent e ) {
@@ -126,12 +124,13 @@ public class FlatPasswordFieldUI
 				repaint( e );
 			}
 			private void repaint( KeyEvent e ) {
-				if( e.getKeyCode() == KeyEvent.VK_CAPS_LOCK )
+				if( e.getKeyCode() == KeyEvent.VK_CAPS_LOCK ) {
 					e.getComponent().repaint();
+					scrollCaretToVisible();
+				}
 			}
 		};
 
-		getComponent().addFocusListener( focusListener );
 		getComponent().addKeyListener( capsLockListener );
 	}
 
@@ -139,63 +138,74 @@ public class FlatPasswordFieldUI
 	protected void uninstallListeners() {
 		super.uninstallListeners();
 
-		getComponent().removeFocusListener( focusListener );
 		getComponent().removeKeyListener( capsLockListener );
-		focusListener = null;
 		capsLockListener = null;
 	}
 
 	@Override
-	protected Caret createCaret() {
-		return new FlatCaret( UIManager.getString( "TextComponent.selectAllOnFocusPolicy" ) );
+	protected void installKeyboardActions() {
+		super.installKeyboardActions();
+
+		// map "select-word" action (double-click) to "select-line" action
+		ActionMap map = SwingUtilities.getUIActionMap( getComponent() );
+		if( map != null && map.get( DefaultEditorKit.selectWordAction ) != null ) {
+			Action selectLineAction = map.get( DefaultEditorKit.selectLineAction );
+			if( selectLineAction != null )
+				map.put( DefaultEditorKit.selectWordAction, selectLineAction );
+		}
 	}
 
 	@Override
-	protected void propertyChange( PropertyChangeEvent e ) {
-		super.propertyChange( e );
-
-		if( FlatClientProperties.PLACEHOLDER_TEXT.equals( e.getPropertyName() ) )
-			getComponent().repaint();
+	public View create( Element elem ) {
+		return new PasswordView( elem );
 	}
 
 	@Override
 	protected void paintSafely( Graphics g ) {
-		FlatTextFieldUI.paintBackground( g, getComponent(), focusWidth, arc, isIntelliJTheme );
-		FlatTextFieldUI.paintPlaceholder( g, getComponent(), placeholderForeground );
-		paintCapsLock( g );
+		// safe and restore clipping area because super.paintSafely() modifies it
+		// and the caps lock icon would be truncated
+		Shape oldClip = g.getClip();
 		super.paintSafely( g );
+		g.setClip( oldClip );
+
+		paintCapsLock( g );
 	}
 
 	protected void paintCapsLock( Graphics g ) {
-		JTextComponent c = getComponent();
-		if( !c.isFocusOwner() ||
-			!Toolkit.getDefaultToolkit().getLockingKeyState( KeyEvent.VK_CAPS_LOCK ) )
-		  return;
+		if( !isCapsLockVisible() )
+			return;
 
+		JTextComponent c = getComponent();
 		int y = (c.getHeight() - capsLockIcon.getIconHeight()) / 2;
-		int x = c.getWidth() - capsLockIcon.getIconWidth() - y;
+		int x = c.getComponentOrientation().isLeftToRight()
+			? c.getWidth() - capsLockIcon.getIconWidth() - y
+			: y;
 		capsLockIcon.paintIcon( c, g, x, y );
 	}
 
-	@Override
-	protected void paintBackground( Graphics g ) {
-		// background is painted elsewhere
+	/**
+	 * @since 1.4
+	 */
+	protected boolean isCapsLockVisible() {
+		if( !showCapsLock )
+			return false;
+
+		JTextComponent c = getComponent();
+		return FlatUIUtils.isPermanentFocusOwner( c ) &&
+			Toolkit.getDefaultToolkit().getLockingKeyState( KeyEvent.VK_CAPS_LOCK );
 	}
 
+	/**
+	 * @since 1.4
+	 */
 	@Override
-	public Dimension getPreferredSize( JComponent c ) {
-		return applyMinimumWidth( super.getPreferredSize( c ), c );
-	}
+	protected Insets getPadding() {
+		Insets padding = super.getPadding();
+		if( !isCapsLockVisible() )
+			return padding;
 
-	@Override
-	public Dimension getMinimumSize( JComponent c ) {
-		return applyMinimumWidth( super.getMinimumSize( c ), c );
-	}
-
-	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;
+		boolean ltr = getComponent().getComponentOrientation().isLeftToRight();
+		int iconWidth = capsLockIcon.getIconWidth();
+		return FlatUIUtils.addInsets( padding, new Insets( 0, ltr ? 0 : iconWidth, 0, ltr ? iconWidth : 0 ) );
 	}
 }

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

@@ -0,0 +1,545 @@
+/*
+ * Copyright 2020 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.ui;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.GraphicsConfiguration;
+import java.awt.GraphicsDevice;
+import java.awt.GraphicsEnvironment;
+import java.awt.Insets;
+import java.awt.MouseInfo;
+import java.awt.Panel;
+import java.awt.Point;
+import java.awt.PointerInfo;
+import java.awt.Rectangle;
+import java.awt.Toolkit;
+import java.awt.Window;
+import java.awt.event.ComponentEvent;
+import java.awt.event.ComponentListener;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import javax.swing.JComponent;
+import javax.swing.JLayeredPane;
+import javax.swing.JPanel;
+import javax.swing.JToolTip;
+import javax.swing.JWindow;
+import javax.swing.Popup;
+import javax.swing.PopupFactory;
+import javax.swing.RootPaneContainer;
+import javax.swing.SwingUtilities;
+import javax.swing.ToolTipManager;
+import javax.swing.UIManager;
+import javax.swing.border.Border;
+import com.formdev.flatlaf.FlatClientProperties;
+import com.formdev.flatlaf.util.SystemInfo;
+import com.formdev.flatlaf.util.UIScale;
+
+/**
+ * A popup factory that adds drop shadows to popups on Windows.
+ * On macOS and Linux, heavy weight popups (without drop shadow) are produced and the
+ * operating system automatically adds drop shadows.
+ *
+ * @author Karl Tauber
+ */
+public class FlatPopupFactory
+	extends PopupFactory
+{
+	private Method java8getPopupMethod;
+	private Method java9getPopupMethod;
+
+	@Override
+	public Popup getPopup( Component owner, Component contents, int x, int y )
+		throws IllegalArgumentException
+	{
+		Point pt = fixToolTipLocation( owner, contents, x, y );
+		if( pt != null ) {
+			x = pt.x;
+			y = pt.y;
+		}
+
+		boolean forceHeavyWeight = isOptionEnabled( owner, contents, FlatClientProperties.POPUP_FORCE_HEAVY_WEIGHT, "Popup.forceHeavyWeight" );
+
+		if( !isOptionEnabled( owner, contents, FlatClientProperties.POPUP_DROP_SHADOW_PAINTED, "Popup.dropShadowPainted" ) || SystemInfo.isProjector || SystemInfo.isWebswing )
+			return new NonFlashingPopup( getPopupForScreenOfOwner( owner, contents, x, y, forceHeavyWeight ), contents );
+
+		// macOS and Linux adds drop shadow to heavy weight popups
+		if( SystemInfo.isMacOS || SystemInfo.isLinux )
+			return new NonFlashingPopup( getPopupForScreenOfOwner( owner, contents, x, y, true ), contents );
+
+		// create drop shadow popup
+		return new DropShadowPopup( getPopupForScreenOfOwner( owner, contents, x, y, forceHeavyWeight ), owner, contents );
+	}
+
+	/**
+	 * Creates a popup for the screen that the owner component is on.
+	 * <p>
+	 * PopupFactory caches heavy weight popup windows and reuses them.
+	 * On a dual screen setup, if the popup owner has moved from one screen to the other one,
+	 * then the cached heavy weight popup window may be connected to the wrong screen.
+	 * If the two screens use different scaling factors, then the popup location and size
+	 * is scaled when the popup becomes visible, which shows the popup in the wrong location
+	 * (or on wrong screen). The re-scaling is done in WWindowPeer.setBounds() (Java 9+).
+	 * <p>
+	 * To fix this, dispose popup windows that are on wrong screen and get new popup.
+	 * <p>
+	 * This is a workaround for https://bugs.openjdk.java.net/browse/JDK-8224608
+	 */
+	private Popup getPopupForScreenOfOwner( Component owner, Component contents, int x, int y, boolean forceHeavyWeight )
+		throws IllegalArgumentException
+	{
+		int count = 0;
+
+		for(;;) {
+			// create new or get cached popup
+			Popup popup = forceHeavyWeight
+				? getHeavyWeightPopup( owner, contents, x, y )
+				: super.getPopup( owner, contents, x, y );
+
+			// get heavy weight popup window; is null for non-heavy weight popup
+			Window popupWindow = SwingUtilities.windowForComponent( contents );
+
+			// check whether heavy weight popup window is on same screen as owner component
+			if( popupWindow == null ||
+				owner == null ||
+				popupWindow.getGraphicsConfiguration() == owner.getGraphicsConfiguration() )
+			  return popup;
+
+			// remove contents component from popup window
+			if( popupWindow instanceof JWindow )
+				((JWindow)popupWindow).getContentPane().removeAll();
+
+			// dispose unused popup
+			// (do not invoke popup.hide() because this would cache the popup window)
+			popupWindow.dispose();
+
+			// avoid endless loop (should newer happen; PopupFactory cache size is 5)
+			if( ++count > 10 )
+				return popup;
+		}
+	}
+
+	/**
+	 * Shows the given popup and, if necessary, fixes the location of a heavy weight popup window.
+	 * <p>
+	 * On a dual screen setup, where screens use different scale factors, it may happen
+	 * that the window location changes when showing a heavy weight popup window.
+	 * E.g. when opening an dialog on the secondary screen and making combobox popup visible.
+	 * <p>
+	 * This is a workaround for https://bugs.openjdk.java.net/browse/JDK-8224608
+	 */
+	private static void showPopupAndFixLocation( Popup popup, Window popupWindow ) {
+		if( popupWindow != null ) {
+			// remember location of heavy weight popup window
+			int x = popupWindow.getX();
+			int y = popupWindow.getY();
+
+			popup.show();
+
+			// restore popup window location if it has changed
+			// (probably scaled when screens use different scale factors)
+			if( popupWindow.getX() != x || popupWindow.getY() != y )
+				popupWindow.setLocation( x, y );
+		} else
+			popup.show();
+	}
+
+	private boolean isOptionEnabled( Component owner, Component contents, String clientKey, String uiKey ) {
+		if( owner instanceof JComponent ) {
+			Boolean b = FlatClientProperties.clientPropertyBooleanStrict( (JComponent) owner, clientKey, null );
+			if( b != null )
+				return b;
+		}
+
+		if( contents instanceof JComponent ) {
+			Boolean b = FlatClientProperties.clientPropertyBooleanStrict( (JComponent) contents, clientKey, null );
+			if( b != null )
+				return b;
+		}
+
+		return UIManager.getBoolean( uiKey );
+	}
+
+	/**
+	 * There is no API in Java 8 to force creation of heavy weight popups,
+	 * but it is possible with reflection. Java 9 provides a new method.
+	 *
+	 * When changing FlatLaf system requirements to Java 9+,
+	 * then this method can be replaced with:
+	 *    return getPopup( owner, contents, x, y, true );
+	 */
+	private Popup getHeavyWeightPopup( Component owner, Component contents, int x, int y )
+		throws IllegalArgumentException
+	{
+		try {
+			if( SystemInfo.isJava_9_orLater ) {
+				if( java9getPopupMethod == null ) {
+					java9getPopupMethod = PopupFactory.class.getDeclaredMethod(
+						"getPopup", Component.class, Component.class, int.class, int.class, boolean.class );
+				}
+				return (Popup) java9getPopupMethod.invoke( this, owner, contents, x, y, true );
+			} else {
+				// Java 8
+				if( java8getPopupMethod == null ) {
+					java8getPopupMethod = PopupFactory.class.getDeclaredMethod(
+						"getPopup", Component.class, Component.class, int.class, int.class, int.class );
+					java8getPopupMethod.setAccessible( true );
+				}
+				return (Popup) java8getPopupMethod.invoke( this, owner, contents, x, y, /*HEAVY_WEIGHT_POPUP*/ 2 );
+			}
+		} catch( NoSuchMethodException | SecurityException | IllegalAccessException | InvocationTargetException ex ) {
+			// ignore
+			return null;
+		}
+	}
+
+	/**
+	 * Usually ToolTipManager places a tooltip at (mouseLocation.x, mouseLocation.y + 20).
+	 * In case that the tooltip would be partly outside of the screen,
+	 * the ToolTipManager changes the location so that the entire tooltip fits on screen.
+	 * But this can place the tooltip under the mouse location and hide the owner component.
+	 * <p>
+	 * This method checks whether the current mouse location is within tooltip bounds
+	 * and corrects the y-location so that the tooltip is placed above the mouse location.
+	 */
+	private Point fixToolTipLocation( Component owner, Component contents, int x, int y ) {
+		if( !(contents instanceof JToolTip) || !wasInvokedFromToolTipManager() )
+			return null;
+
+		PointerInfo pointerInfo = MouseInfo.getPointerInfo();
+		if( pointerInfo == null )
+			return null;
+
+		Point mouseLocation = pointerInfo.getLocation();
+		Dimension tipSize = contents.getPreferredSize();
+
+		// check whether mouse location is within tooltip bounds
+		Rectangle tipBounds = new Rectangle( x, y, tipSize.width, tipSize.height );
+		if( !tipBounds.contains( mouseLocation ) )
+			return null;
+
+		// find GraphicsConfiguration at mouse location (similar to ToolTipManager.getDrawingGC())
+		GraphicsConfiguration gc = null;
+		for( GraphicsDevice device : GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices() ) {
+			GraphicsConfiguration dgc = device.getDefaultConfiguration();
+			if( dgc.getBounds().contains( mouseLocation ) ) {
+				gc = dgc;
+				break;
+			}
+		}
+		if( gc == null )
+			gc = owner.getGraphicsConfiguration();
+		if( gc == null )
+			return null;
+
+		Rectangle screenBounds = gc.getBounds();
+		Insets screenInsets = Toolkit.getDefaultToolkit().getScreenInsets( gc );
+		int screenTop = screenBounds.y + screenInsets.top;
+
+		// place tooltip above mouse location if there is enough space
+		int newY =  mouseLocation.y - tipSize.height - UIScale.scale( 20 );
+		if( newY < screenTop )
+			return null;
+
+		return new Point( x, newY );
+	}
+
+	private boolean wasInvokedFromToolTipManager() {
+		return StackUtils.wasInvokedFrom( ToolTipManager.class.getName(), "showTipWindow", 8 );
+	}
+
+	//---- class NonFlashingPopup ---------------------------------------------
+
+	private class NonFlashingPopup
+		extends Popup
+	{
+		private Popup delegate;
+		private Component contents;
+
+		// heavy weight
+		protected Window popupWindow;
+		private Color oldPopupWindowBackground;
+
+		NonFlashingPopup( Popup delegate, Component contents ) {
+			this.delegate = delegate;
+			this.contents = contents;
+
+			popupWindow = SwingUtilities.windowForComponent( contents );
+			if( popupWindow != null ) {
+				// heavy weight popup
+
+				// fix background flashing which may occur on some platforms
+				// (e.g. macOS and Linux) when using dark theme
+				oldPopupWindowBackground = popupWindow.getBackground();
+				popupWindow.setBackground( contents.getBackground() );
+			}
+		}
+
+		@Override
+		public void show() {
+			if( delegate != null ) {
+				showPopupAndFixLocation( delegate, popupWindow );
+
+				// increase tooltip size if necessary because it may be too small on HiDPI screens
+				//    https://bugs.openjdk.java.net/browse/JDK-8213535
+				if( contents instanceof JToolTip && popupWindow == null ) {
+					Container parent = contents.getParent();
+					if( parent instanceof JPanel ) {
+						Dimension prefSize = parent.getPreferredSize();
+						if( !prefSize.equals( parent.getSize() ) ) {
+							Container mediumWeightPanel = SwingUtilities.getAncestorOfClass( Panel.class, parent );
+							Container c = (mediumWeightPanel != null)
+								? mediumWeightPanel // medium weight popup
+								: parent;           // light weight popup
+							c.setSize( prefSize );
+							c.validate();
+						}
+					}
+				}
+			}
+		}
+
+		@Override
+		public void hide() {
+			if( delegate != null ) {
+				delegate.hide();
+				delegate = null;
+				contents = null;
+			}
+
+			if( popupWindow != null ) {
+				// restore background so that it can not affect other LaFs (when switching)
+				// because popup windows are cached and reused
+				popupWindow.setBackground( oldPopupWindowBackground );
+				popupWindow = null;
+			}
+		}
+	}
+
+	//---- class DropShadowPopup ----------------------------------------------
+
+	private class DropShadowPopup
+		extends NonFlashingPopup
+	{
+		private final Component owner;
+
+		// light weight
+		private JComponent lightComp;
+		private Border oldBorder;
+		private boolean oldOpaque;
+
+		// medium weight
+		private boolean mediumWeightShown;
+		private Panel mediumWeightPanel;
+		private JPanel dropShadowPanel;
+		private ComponentListener mediumPanelListener;
+
+		// heavy weight
+		private Popup dropShadowDelegate;
+		private Window dropShadowWindow;
+		private Color oldDropShadowWindowBackground;
+
+		DropShadowPopup( Popup delegate, Component owner, Component contents ) {
+			super( delegate, contents );
+			this.owner = owner;
+
+			Dimension size = contents.getPreferredSize();
+			if( size.width <= 0 || size.height <= 0 )
+				return;
+
+			if( popupWindow != null ) {
+				// heavy weight popup
+
+				// Since Java has a problem with sub-pixel text rendering on translucent
+				// windows, we can not make the popup window translucent for the drop shadow.
+				// (see https://bugs.openjdk.java.net/browse/JDK-8215980)
+				// The solution is to create a second translucent window that paints
+				// the drop shadow and is positioned behind the popup window.
+
+				// create panel that paints the drop shadow
+				JPanel dropShadowPanel = new JPanel();
+				dropShadowPanel.setBorder( createDropShadowBorder() );
+				dropShadowPanel.setOpaque( false );
+
+				// set preferred size of drop shadow panel
+				Dimension prefSize = popupWindow.getPreferredSize();
+				Insets insets = dropShadowPanel.getInsets();
+				dropShadowPanel.setPreferredSize( new Dimension(
+					prefSize.width + insets.left + insets.right,
+					prefSize.height + insets.top + insets.bottom ) );
+
+				// create heavy weight popup for drop shadow
+				int x = popupWindow.getX() - insets.left;
+				int y = popupWindow.getY() - insets.top;
+				dropShadowDelegate = getPopupForScreenOfOwner( owner, dropShadowPanel, x, y, true );
+
+				// make drop shadow popup window translucent
+				dropShadowWindow = SwingUtilities.windowForComponent( dropShadowPanel );
+				if( dropShadowWindow != null ) {
+					oldDropShadowWindowBackground = dropShadowWindow.getBackground();
+					dropShadowWindow.setBackground( new Color( 0, true ) );
+				}
+			} else {
+				mediumWeightPanel = (Panel) SwingUtilities.getAncestorOfClass( Panel.class, contents );
+				if( mediumWeightPanel != null ) {
+					// medium weight popup
+					dropShadowPanel = new JPanel();
+					dropShadowPanel.setBorder( createDropShadowBorder() );
+					dropShadowPanel.setOpaque( false );
+					dropShadowPanel.setSize( FlatUIUtils.addInsets( mediumWeightPanel.getSize(), dropShadowPanel.getInsets() ) );
+				} else {
+					// light weight popup
+					Container p = contents.getParent();
+					if( !(p instanceof JComponent) )
+						return;
+
+					lightComp = (JComponent) p;
+					oldBorder = lightComp.getBorder();
+					oldOpaque = lightComp.isOpaque();
+					lightComp.setBorder( createDropShadowBorder() );
+					lightComp.setOpaque( false );
+					lightComp.setSize( lightComp.getPreferredSize() );
+				}
+			}
+		}
+
+		private Border createDropShadowBorder() {
+			return new FlatDropShadowBorder(
+				UIManager.getColor( "Popup.dropShadowColor" ),
+				UIManager.getInsets( "Popup.dropShadowInsets" ),
+				FlatUIUtils.getUIFloat( "Popup.dropShadowOpacity", 0.5f ) );
+		}
+
+		@Override
+		public void show() {
+			if( dropShadowDelegate != null )
+				showPopupAndFixLocation( dropShadowDelegate, dropShadowWindow );
+
+			if( mediumWeightPanel != null )
+				showMediumWeightDropShadow();
+
+			super.show();
+
+			// fix location of light weight popup in case it has left or top drop shadow
+			if( lightComp != null ) {
+				Insets insets = lightComp.getInsets();
+				if( insets.left != 0 || insets.top != 0 )
+					lightComp.setLocation( lightComp.getX() - insets.left, lightComp.getY() - insets.top );
+			}
+		}
+
+		@Override
+		public void hide() {
+			if( dropShadowDelegate != null ) {
+				dropShadowDelegate.hide();
+				dropShadowDelegate = null;
+			}
+
+			if( mediumWeightPanel != null ) {
+				hideMediumWeightDropShadow();
+				dropShadowPanel = null;
+				mediumWeightPanel = null;
+			}
+
+			super.hide();
+
+			if( dropShadowWindow != null ) {
+				dropShadowWindow.setBackground( oldDropShadowWindowBackground );
+				dropShadowWindow = null;
+			}
+
+			if( lightComp != null ) {
+				lightComp.setBorder( oldBorder );
+				lightComp.setOpaque( oldOpaque );
+				lightComp = null;
+			}
+		}
+
+		private void showMediumWeightDropShadow() {
+			if( mediumWeightShown )
+				return;
+
+			mediumWeightShown = true;
+
+			if( owner == null )
+				return;
+
+			Window window = SwingUtilities.windowForComponent( owner );
+			if( !(window instanceof RootPaneContainer) )
+				return;
+
+			dropShadowPanel.setVisible( false );
+
+			JLayeredPane layeredPane = ((RootPaneContainer)window).getLayeredPane();
+			layeredPane.add( dropShadowPanel, JLayeredPane.POPUP_LAYER, 0 );
+
+			moveMediumWeightDropShadow();
+			resizeMediumWeightDropShadow();
+
+			mediumPanelListener = new ComponentListener() {
+				@Override
+				public void componentShown( ComponentEvent e ) {
+					if( dropShadowPanel != null )
+						dropShadowPanel.setVisible( true );
+				}
+
+				@Override
+				public void componentHidden( ComponentEvent e ) {
+					if( dropShadowPanel != null )
+						dropShadowPanel.setVisible( false );
+				}
+
+				@Override
+				public void componentMoved( ComponentEvent e ) {
+					moveMediumWeightDropShadow();
+				}
+
+				@Override
+				public void componentResized( ComponentEvent e ) {
+					resizeMediumWeightDropShadow();
+				}
+			};
+			mediumWeightPanel.addComponentListener( mediumPanelListener );
+		}
+
+		private void hideMediumWeightDropShadow() {
+			mediumWeightPanel.removeComponentListener( mediumPanelListener );
+
+			Container parent = dropShadowPanel.getParent();
+			if( parent != null ) {
+				Rectangle bounds = dropShadowPanel.getBounds();
+				parent.remove( dropShadowPanel );
+				parent.repaint( bounds.x, bounds.y, bounds.width, bounds.height );
+			}
+		}
+
+		private void moveMediumWeightDropShadow() {
+			if( dropShadowPanel != null && mediumWeightPanel != null ) {
+				Point location = mediumWeightPanel.getLocation();
+				Insets insets = dropShadowPanel.getInsets();
+				dropShadowPanel.setLocation( location.x - insets.left, location.y - insets.top );
+			}
+		}
+
+		private void resizeMediumWeightDropShadow() {
+			if( dropShadowPanel != null && mediumWeightPanel != null )
+				dropShadowPanel.setSize( FlatUIUtils.addInsets( mediumWeightPanel.getSize(), dropShadowPanel.getInsets() ) );
+		}
+	}
+}

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

@@ -24,8 +24,8 @@ import javax.swing.plaf.ComponentUI;
  *
  * <!-- BasicSeparatorUI -->
  *
- * @uiDefault PopupMenuSeparator.background		Color	unused
- * @uiDefault PopupMenuSeparator.foreground		Color
+ * @uiDefault Separator.background				Color	unused
+ * @uiDefault Separator.foreground				Color
  *
  * <!-- FlatSeparatorUI -->
  *
@@ -38,12 +38,8 @@ import javax.swing.plaf.ComponentUI;
 public class FlatPopupMenuSeparatorUI
 	extends FlatSeparatorUI
 {
-	private static ComponentUI instance;
-
 	public static ComponentUI createUI( JComponent c ) {
-		if( instance == null )
-			instance = new FlatPopupMenuSeparatorUI();
-		return instance;
+		return FlatUIUtils.createSharedUI( FlatPopupMenuSeparatorUI.class, FlatPopupMenuSeparatorUI::new );
 	}
 
 	@Override

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

@@ -31,6 +31,7 @@ import javax.swing.LookAndFeel;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicProgressBarUI;
+import com.formdev.flatlaf.util.HiDPIUtils;
 import com.formdev.flatlaf.util.UIScale;
 
 /**
@@ -154,7 +155,7 @@ public class FlatProgressBarUI
 			? 0
 			: Math.min( UIScale.scale( this.arc ), horizontal ? height : width );
 
-		FlatUIUtils.setRenderingHints( (Graphics2D) g );
+		Object[] oldRenderingHints = FlatUIUtils.setRenderingHints( g );
 
 		// paint track
 		RoundRectangle2D.Float trackShape = new RoundRectangle2D.Float( x, y, width, height, arc, arc );
@@ -162,6 +163,7 @@ public class FlatProgressBarUI
 		((Graphics2D)g).fill( trackShape );
 
 		// paint progress
+		int amountFull = 0;
 		if( progressBar.isIndeterminate() ) {
 			boxRect = getBox( boxRect );
 			if( boxRect != null ) {
@@ -169,11 +171,8 @@ public class FlatProgressBarUI
 				((Graphics2D)g).fill( new RoundRectangle2D.Float( boxRect.x, boxRect.y,
 					boxRect.width, boxRect.height, arc, arc ) );
 			}
-
-			if( progressBar.isStringPainted() )
-				paintString( g, x, y, width, height, 0, insets );
 		} else {
-			int amountFull = getAmountFull( insets, width, height );
+			amountFull = getAmountFull( insets, width, height );
 
 			RoundRectangle2D.Float progressShape = horizontal
 				? new RoundRectangle2D.Float( c.getComponentOrientation().isLeftToRight() ? x : x + (width - amountFull),
@@ -188,10 +187,17 @@ public class FlatProgressBarUI
 				((Graphics2D)g).fill( area );
 			} else
 				((Graphics2D)g).fill( progressShape );
-
-			if( progressBar.isStringPainted() )
-				paintString( g, x, y, width, height, amountFull, insets );
 		}
+
+		FlatUIUtils.resetRenderingHints( g, oldRenderingHints );
+
+		if( progressBar.isStringPainted() )
+			paintString( g, x, y, width, height, amountFull, insets );
+	}
+
+	@Override
+	protected void paintString( Graphics g, int x, int y, int width, int height, int amountFull, Insets b ) {
+		super.paintString( HiDPIUtils.createGraphicsTextYCorrection( (Graphics2D) g ), x, y, width, height, amountFull, b );
 	}
 
 	@Override

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

@@ -16,12 +16,11 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
+import java.awt.Dimension;
 import java.awt.Graphics;
-import java.awt.Rectangle;
-import java.beans.PropertyChangeListener;
+import javax.swing.Icon;
 import javax.swing.JComponent;
-import javax.swing.JMenuItem;
+import javax.swing.LookAndFeel;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicRadioButtonMenuItemUI;
 
@@ -46,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();
 	}
@@ -61,25 +65,30 @@ public class FlatRadioButtonMenuItemUI
 	protected void installDefaults() {
 		super.installDefaults();
 
-		// scale
-		defaultTextIconGap = scale( defaultTextIconGap );
-	}
+		LookAndFeel.installProperty( menuItem, "iconTextGap", FlatUIUtils.getUIInt( "MenuItem.iconTextGap", 4 ) );
 
-	/**
-	 * 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 );
-		};
+		renderer = createRenderer();
 	}
 
 	@Override
-	protected void paintText( Graphics g, JMenuItem menuItem, Rectangle textRect, String text ) {
-		FlatMenuItemUI.paintText( g, menuItem, textRect, text, disabledForeground, selectionForeground );
+	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

@@ -18,17 +18,18 @@ package com.formdev.flatlaf.ui;
 
 import static com.formdev.flatlaf.util.UIScale.scale;
 import java.awt.Color;
+import java.awt.Container;
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.awt.Insets;
 import java.awt.Rectangle;
+import java.util.Objects;
 import javax.swing.AbstractButton;
 import javax.swing.CellRendererPane;
 import javax.swing.JComponent;
 import javax.swing.LookAndFeel;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
-import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicRadioButtonUI;
 import com.formdev.flatlaf.icons.FlatCheckBoxIcon;
 import com.formdev.flatlaf.util.UIScale;
@@ -59,14 +60,12 @@ public class FlatRadioButtonUI
 	protected int iconTextGap;
 	protected Color disabledText;
 
+	private Color defaultBackground;
+
 	private boolean defaults_initialized = false;
 
-	private static ComponentUI instance;
-
 	public static ComponentUI createUI( JComponent c ) {
-		if( instance == null )
-			instance = new FlatRadioButtonUI();
-		return instance;
+		return FlatUIUtils.createSharedUI( FlatRadioButtonUI.class, FlatRadioButtonUI::new );
 	}
 
 	@Override
@@ -79,6 +78,8 @@ public class FlatRadioButtonUI
 			iconTextGap = FlatUIUtils.getUIInt( prefix + "iconTextGap", 4 );
 			disabledText = UIManager.getColor( prefix + "disabledText" );
 
+			defaultBackground = UIManager.getColor( prefix + "background" );
+
 			defaults_initialized = true;
 		}
 
@@ -122,11 +123,11 @@ public class FlatRadioButtonUI
 	public void paint( Graphics g, JComponent c ) {
 		// 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 background color is different to default background color
+		// (this paints selection if using the component as cell renderer)
 		if( !c.isOpaque() &&
 			((AbstractButton)c).isContentAreaFilled() &&
-			(c.getParent() instanceof CellRendererPane || !(c.getBackground() instanceof UIResource)))
+			!Objects.equals( c.getBackground(), getDefaultBackground( c ) ) )
 		{
 			g.setColor( c.getBackground() );
 			g.fillRect( 0, 0, c.getWidth(), c.getHeight() );
@@ -155,7 +156,7 @@ public class FlatRadioButtonUI
 			}
 		}
 
-		super.paint( g, c );
+		super.paint( FlatLabelUI.createGraphicsHTMLTextYCorrection( g, c ), c );
 	}
 
 	@Override
@@ -163,6 +164,18 @@ public class FlatRadioButtonUI
 		FlatButtonUI.paintText( g, b, textRect, text, b.isEnabled() ? b.getForeground() : disabledText );
 	}
 
+	/**
+	 * Returns the default background color of the component.
+	 * If the component is used as cell renderer (e.g. in JTable),
+	 * then the background color of the renderer container is returned.
+	 */
+	private Color getDefaultBackground( JComponent c ) {
+		Container parent = c.getParent();
+		return (parent instanceof CellRendererPane && parent.getParent() != null)
+			? parent.getParent().getBackground()
+			: defaultBackground;
+	}
+
 	private int getIconFocusWidth( JComponent c ) {
 		AbstractButton b = (AbstractButton) c;
 		return (b.getIcon() == null && getDefaultIcon() instanceof FlatCheckBoxIcon)

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

@@ -16,23 +16,523 @@
 
 package com.formdev.flatlaf.ui;
 
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.Frame;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Insets;
+import java.awt.LayoutManager;
+import java.awt.LayoutManager2;
+import java.awt.Window;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
+import java.awt.event.ComponentListener;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.function.Function;
 import javax.swing.JComponent;
+import javax.swing.JDialog;
+import javax.swing.JFrame;
+import javax.swing.JLayeredPane;
+import javax.swing.JMenuBar;
+import javax.swing.JRootPane;
+import javax.swing.LookAndFeel;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.border.Border;
+import javax.swing.plaf.BorderUIResource;
 import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.RootPaneUI;
+import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicRootPaneUI;
+import com.formdev.flatlaf.FlatClientProperties;
+import com.formdev.flatlaf.FlatLaf;
+import com.formdev.flatlaf.util.HiDPIUtils;
+import com.formdev.flatlaf.util.SystemInfo;
+import com.formdev.flatlaf.util.UIScale;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JRootPane}.
  *
+ * <!-- FlatRootPaneUI -->
+ *
+ * @uiDefault RootPane.border								Border
+ * @uiDefault RootPane.activeBorderColor					Color
+ * @uiDefault RootPane.inactiveBorderColor					Color
+ * @uiDefault TitlePane.borderColor							Color	optional
+ *
+ * <!-- FlatWindowResizer -->
+ *
+ * @uiDefault RootPane.borderDragThickness					int
+ * @uiDefault RootPane.cornerDragWidth						int
+ * @uiDefault RootPane.honorFrameMinimumSizeOnResize		boolean
+ * @uiDefault RootPane.honorDialogMinimumSizeOnResize		boolean
+ *
  * @author Karl Tauber
  */
 public class FlatRootPaneUI
 	extends BasicRootPaneUI
 {
-	private static ComponentUI instance;
+	protected final Color borderColor = UIManager.getColor( "TitlePane.borderColor" );
+
+	protected JRootPane rootPane;
+	protected FlatTitlePane titlePane;
+	protected FlatWindowResizer windowResizer;
+
+	private Object nativeWindowBorderData;
+	private LayoutManager oldLayout;
+	private PropertyChangeListener ancestorListener;
+	private ComponentListener componentListener;
 
 	public static ComponentUI createUI( JComponent c ) {
-		if( instance == null )
-			instance = new FlatRootPaneUI();
-		return instance;
+		return new FlatRootPaneUI();
+	}
+
+	@Override
+	public void installUI( JComponent c ) {
+		super.installUI( c );
+
+		rootPane = (JRootPane) c;
+
+		if( rootPane.getWindowDecorationStyle() != JRootPane.NONE )
+			installClientDecorations();
+		else
+			installBorder();
+
+		installNativeWindowBorder();
+	}
+
+	protected void installBorder() {
+		if( borderColor != null ) {
+			Border b = rootPane.getBorder();
+			if( b == null || b instanceof UIResource )
+				rootPane.setBorder( new FlatWindowTitleBorder( borderColor ) );
+		}
+	}
+
+	@Override
+	public void uninstallUI( JComponent c ) {
+		super.uninstallUI( c );
+
+		uninstallNativeWindowBorder();
+		uninstallClientDecorations();
+		rootPane = null;
+	}
+
+	@Override
+	protected void installDefaults( JRootPane c ) {
+		super.installDefaults( c );
+
+		// Update background color of JFrame or JDialog parent to avoid bad border
+		// on HiDPI screens when switching from light to dark Laf.
+		// The background of JFrame is initialized in JFrame.frameInit() and
+		// the background of JDialog in JDialog.dialogInit(),
+		// but it was not updated when switching Laf.
+		Container parent = c.getParent();
+		if( parent instanceof JFrame || parent instanceof JDialog ) {
+			Color background = parent.getBackground();
+			if( background == null || background instanceof UIResource )
+				parent.setBackground( UIManager.getColor( "control" ) );
+		}
+
+		// enable dark window appearance on macOS when running in JetBrains Runtime
+		if( SystemInfo.isJetBrainsJVM && SystemInfo.isMacOS_10_14_Mojave_orLater )
+			c.putClientProperty( "jetbrains.awt.windowDarkAppearance", FlatLaf.isLafDark() );
+	}
+
+	@Override
+	protected void installListeners( JRootPane root ) {
+		super.installListeners( root );
+
+		if( SystemInfo.isJava_9_orLater ) {
+			// On HiDPI screens, where scaling is used, there may be white lines at the
+			// bottom and at the right side of the window when it is initially shown.
+			// This is very disturbing in dark themes, but hard to notice in light themes.
+			// Seems to be a rounding issue when Swing adds dirty region of window
+			// using RepaintManager.nativeAddDirtyRegion().
+			//
+			// Note: Not using a HierarchyListener here, which would be much easier,
+			// because this causes problems with mouse clicks in heavy-weight popups.
+			// Instead, add a listener to the root pane that waits until it is added
+			// to a window, then add a component listener to the window.
+			// See: https://github.com/JFormDesigner/FlatLaf/issues/371
+			ancestorListener = e -> {
+				Object oldValue = e.getOldValue();
+				Object newValue = e.getNewValue();
+				if( newValue instanceof Window ) {
+					if( componentListener == null ) {
+						componentListener = new ComponentAdapter() {
+							@Override
+							public void componentShown( ComponentEvent e ) {
+								// add whole root pane to dirty regions when window is initially shown
+								root.getParent().repaint( root.getX(), root.getY(), root.getWidth(), root.getHeight() );
+							}
+						};
+					}
+					((Window)newValue).addComponentListener( componentListener );
+				} else if( newValue == null && oldValue instanceof Window ) {
+					if( componentListener != null )
+						((Window)oldValue).removeComponentListener( componentListener );
+				}
+			};
+			root.addPropertyChangeListener( "ancestor", ancestorListener );
+		}
+	}
+
+	@Override
+	protected void uninstallListeners( JRootPane root ) {
+		super.uninstallListeners( root );
+
+		if( SystemInfo.isJava_9_orLater ) {
+			if( componentListener != null ) {
+				Window window = SwingUtilities.windowForComponent( root );
+				if( window != null )
+					window.removeComponentListener( componentListener );
+				componentListener = null;
+			}
+			root.removePropertyChangeListener( "ancestor", ancestorListener );
+			ancestorListener = null;
+		}
+	}
+
+	/**
+	 * @since 1.1.2
+	 */
+	protected void installNativeWindowBorder() {
+		nativeWindowBorderData = FlatNativeWindowBorder.install( rootPane );
+	}
+
+	/**
+	 * @since 1.1.2
+	 */
+	protected void uninstallNativeWindowBorder() {
+		FlatNativeWindowBorder.uninstall( rootPane, nativeWindowBorderData );
+		nativeWindowBorderData = null;
+	}
+
+	/**
+	 * @since 1.1.2
+	 */
+	public static void updateNativeWindowBorder( JRootPane rootPane ) {
+		RootPaneUI rui = rootPane.getUI();
+		if( !(rui instanceof FlatRootPaneUI) )
+			return;
+
+		FlatRootPaneUI ui = (FlatRootPaneUI) rui;
+		ui.uninstallNativeWindowBorder();
+		ui.installNativeWindowBorder();
+	}
+
+	protected void installClientDecorations() {
+		boolean isNativeWindowBorderSupported = FlatNativeWindowBorder.isSupported();
+
+		// install border
+		if( rootPane.getWindowDecorationStyle() != JRootPane.NONE && !isNativeWindowBorderSupported )
+			LookAndFeel.installBorder( rootPane, "RootPane.border" );
+		else
+			LookAndFeel.uninstallBorder( rootPane );
+
+		// install title pane
+		setTitlePane( createTitlePane() );
+
+		// install layout
+		oldLayout = rootPane.getLayout();
+		rootPane.setLayout( createRootLayout() );
+
+		// install window resizer
+		if( !isNativeWindowBorderSupported )
+			windowResizer = createWindowResizer();
+	}
+
+	protected void uninstallClientDecorations() {
+		LookAndFeel.uninstallBorder( rootPane );
+		setTitlePane( null );
+
+		if( windowResizer != null ) {
+			windowResizer.uninstall();
+			windowResizer = null;
+		}
+
+		if( oldLayout != null ) {
+			rootPane.setLayout( oldLayout );
+			oldLayout = null;
+		}
+
+		if( rootPane.getWindowDecorationStyle() == JRootPane.NONE ) {
+			rootPane.revalidate();
+			rootPane.repaint();
+		}
+	}
+
+	protected FlatRootLayout createRootLayout() {
+		return new FlatRootLayout();
+	}
+
+	protected FlatWindowResizer createWindowResizer() {
+		return new FlatWindowResizer.WindowResizer( rootPane );
+	}
+
+	protected FlatTitlePane createTitlePane() {
+		return new FlatTitlePane( rootPane );
+	}
+
+	// layer title pane under frame content layer to allow placing menu bar over title pane
+	protected final static Integer TITLE_PANE_LAYER = JLayeredPane.FRAME_CONTENT_LAYER - 1;
+
+	protected void setTitlePane( FlatTitlePane newTitlePane ) {
+		JLayeredPane layeredPane = rootPane.getLayeredPane();
+
+		if( titlePane != null )
+			layeredPane.remove( titlePane );
+
+		if( newTitlePane != null )
+			layeredPane.add( newTitlePane, TITLE_PANE_LAYER );
+
+		titlePane = newTitlePane;
+	}
+
+	@Override
+	public void propertyChange( PropertyChangeEvent e ) {
+		super.propertyChange( e );
+
+		switch( e.getPropertyName() ) {
+			case "windowDecorationStyle":
+				uninstallClientDecorations();
+				if( rootPane.getWindowDecorationStyle() != JRootPane.NONE )
+					installClientDecorations();
+				else
+					installBorder();
+				break;
+
+			case FlatClientProperties.USE_WINDOW_DECORATIONS:
+				updateNativeWindowBorder( rootPane );
+				break;
+
+			case FlatClientProperties.MENU_BAR_EMBEDDED:
+				if( titlePane != null ) {
+					titlePane.menuBarChanged();
+					rootPane.revalidate();
+					rootPane.repaint();
+				}
+				break;
+
+			case FlatClientProperties.TITLE_BAR_BACKGROUND:
+			case FlatClientProperties.TITLE_BAR_FOREGROUND:
+				if( titlePane != null )
+					titlePane.titleBarColorsChanged();
+				break;
+		}
+	}
+
+	protected static boolean isMenuBarEmbedded( JRootPane rootPane ) {
+		RootPaneUI ui = rootPane.getUI();
+		return ui instanceof FlatRootPaneUI &&
+			((FlatRootPaneUI)ui).titlePane != null &&
+			((FlatRootPaneUI)ui).titlePane.isMenuBarEmbedded();
+	}
+
+	//---- class FlatRootLayout -----------------------------------------------
+
+	protected class FlatRootLayout
+		implements LayoutManager2
+	{
+		@Override public void addLayoutComponent( String name, Component comp ) {}
+		@Override public void addLayoutComponent( Component comp, Object constraints ) {}
+		@Override public void removeLayoutComponent( Component comp ) {}
+
+		@Override
+		public Dimension preferredLayoutSize( Container parent ) {
+			return computeLayoutSize( parent, c -> c.getPreferredSize() );
+		}
+
+		@Override
+		public Dimension minimumLayoutSize( Container parent ) {
+			return computeLayoutSize( parent, c -> c.getMinimumSize() );
+		}
+
+		@Override
+		public Dimension maximumLayoutSize( Container parent ) {
+			return new Dimension( Integer.MAX_VALUE, Integer.MAX_VALUE );
+		}
+
+		private Dimension computeLayoutSize( Container parent, Function<Component, Dimension> getSizeFunc ) {
+			JRootPane rootPane = (JRootPane) parent;
+
+			Dimension titlePaneSize = (titlePane != null)
+				? getSizeFunc.apply( titlePane )
+				: new Dimension();
+			Dimension contentSize = (rootPane.getContentPane() != null)
+				? getSizeFunc.apply( rootPane.getContentPane() )
+				: rootPane.getSize();
+
+			int width = contentSize.width; // title pane width is not considered here
+			int height = titlePaneSize.height + contentSize.height;
+			if( titlePane == null || !titlePane.isMenuBarEmbedded() ) {
+				JMenuBar menuBar = rootPane.getJMenuBar();
+				Dimension menuBarSize = (menuBar != null && menuBar.isVisible())
+					? getSizeFunc.apply( menuBar )
+					: new Dimension();
+
+				width = Math.max( width, menuBarSize.width );
+				height += menuBarSize.height;
+			}
+
+			Insets insets = rootPane.getInsets();
+
+			return new Dimension(
+				width + insets.left + insets.right,
+				height + insets.top + insets.bottom );
+		}
+
+		@Override
+		public void layoutContainer( Container parent ) {
+			JRootPane rootPane = (JRootPane) parent;
+			boolean isFullScreen = FlatUIUtils.isFullScreen( rootPane );
+
+			Insets insets = rootPane.getInsets();
+			int x = insets.left;
+			int y = insets.top;
+			int width = rootPane.getWidth() - insets.left - insets.right;
+			int height = rootPane.getHeight() - insets.top - insets.bottom;
+
+			if( rootPane.getLayeredPane() != null )
+				rootPane.getLayeredPane().setBounds( x, y, width, height );
+			if( rootPane.getGlassPane() != null )
+				rootPane.getGlassPane().setBounds( x, y, width, height );
+
+			int nextY = 0;
+			if( titlePane != null ) {
+				int prefHeight = !isFullScreen ? titlePane.getPreferredSize().height : 0;
+				titlePane.setBounds( 0, 0, width, prefHeight );
+				nextY += prefHeight;
+			}
+
+			JMenuBar menuBar = rootPane.getJMenuBar();
+			if( menuBar != null && menuBar.isVisible() ) {
+				boolean embedded = !isFullScreen && titlePane != null && titlePane.isMenuBarEmbedded();
+				if( embedded ) {
+					titlePane.validate();
+					menuBar.setBounds( titlePane.getMenuBarBounds() );
+				} else {
+					Dimension prefSize = menuBar.getPreferredSize();
+					menuBar.setBounds( 0, nextY, width, prefSize.height );
+					nextY += prefSize.height;
+				}
+			}
+
+			Container contentPane = rootPane.getContentPane();
+			if( contentPane != null )
+				contentPane.setBounds( 0, nextY, width, Math.max( height - nextY, 0 ) );
+
+			if( titlePane != null )
+				titlePane.menuBarLayouted();
+		}
+
+		@Override
+		public void invalidateLayout( Container parent ) {
+			if( titlePane != null )
+				titlePane.menuBarChanged();
+		}
+
+		@Override
+		public float getLayoutAlignmentX( Container target ) {
+			return 0;
+		}
+
+		@Override
+		public float getLayoutAlignmentY( Container target ) {
+			return 0;
+		}
+	}
+
+	//---- class FlatWindowBorder ---------------------------------------------
+
+	/**
+	 * Window border used for non-native window decorations.
+	 */
+	public static class FlatWindowBorder
+		extends BorderUIResource.EmptyBorderUIResource
+	{
+		protected final Color activeBorderColor = UIManager.getColor( "RootPane.activeBorderColor" );
+		protected final Color inactiveBorderColor = UIManager.getColor( "RootPane.inactiveBorderColor" );
+		protected final Color baseBorderColor = UIManager.getColor( "Panel.background" );
+
+		public FlatWindowBorder() {
+			super( 1, 1, 1, 1 );
+		}
+
+		@Override
+		public Insets getBorderInsets( Component c, Insets insets ) {
+			if( isWindowMaximized( c ) || FlatUIUtils.isFullScreen( c ) ) {
+				// hide border if window is maximized or full screen
+				insets.top = insets.left = insets.bottom = insets.right = 0;
+				return insets;
+			} else
+				return super.getBorderInsets( c, insets );
+		}
+
+		@Override
+		public void paintBorder( Component c, Graphics g, int x, int y, int width, int height ) {
+			if( isWindowMaximized( c ) || FlatUIUtils.isFullScreen( c ) )
+				return;
+
+			Container parent = c.getParent();
+			boolean active = parent instanceof Window ? ((Window)parent).isActive() : false;
+
+			g.setColor( FlatUIUtils.deriveColor( active ? activeBorderColor : inactiveBorderColor, baseBorderColor ) );
+			HiDPIUtils.paintAtScale1x( (Graphics2D) g, x, y, width, height, this::paintImpl );
+		}
+
+		private void paintImpl( Graphics2D g, int x, int y, int width, int height, double scaleFactor ) {
+			g.drawRect( x, y, width - 1, height - 1 );
+		}
+
+		protected boolean isWindowMaximized( Component c ) {
+			Container parent = c.getParent();
+			return parent instanceof Frame
+				? (((Frame)parent).getExtendedState() & Frame.MAXIMIZED_BOTH) != 0
+				: false;
+		}
+	}
+
+	//---- class FlatWindowTitleBorder ----------------------------------------
+
+	private static class FlatWindowTitleBorder
+		extends BorderUIResource.EmptyBorderUIResource
+	{
+		private final Color borderColor;
+
+		FlatWindowTitleBorder( Color borderColor ) {
+			super( 0, 0, 0, 0 );
+			this.borderColor = borderColor;
+		}
+
+		@Override
+		public void paintBorder( Component c, Graphics g, int x, int y, int width, int height ) {
+			if( showBorder( c ) ) {
+				float lineHeight = UIScale.scale( (float) 1 );
+				FlatUIUtils.paintFilledRectangle( g, borderColor, x, y, width, lineHeight );
+			}
+		}
+
+		@Override
+		public Insets getBorderInsets( Component c, Insets insets ) {
+			insets.set( showBorder( c ) ? 1 : 0, 0, 0, 0 );
+			return insets;
+		}
+
+		private boolean showBorder( Component c ) {
+			Container parent = c.getParent();
+			return
+				(parent instanceof JFrame &&
+				 (((JFrame)parent).getJMenuBar() == null ||
+				  !((JFrame)parent).getJMenuBar().isVisible())) ||
+				(parent instanceof JDialog &&
+				 (((JDialog)parent).getJMenuBar() == null ||
+				  !((JDialog)parent).getJMenuBar().isVisible()));
+		}
 	}
 }

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

@@ -16,7 +16,6 @@
 
 package com.formdev.flatlaf.ui;
 
-import static com.formdev.flatlaf.util.UIScale.scale;
 import java.awt.Component;
 import javax.swing.UIManager;
 
@@ -33,7 +32,11 @@ public class FlatRoundBorder
 	protected final int arc = UIManager.getInt( "Component.arc" );
 
 	@Override
-	protected float getArc( Component c ) {
-		return scale( (float) arc );
+	protected int getArc( Component c ) {
+		if( isCellEditor( c ) )
+			return 0;
+
+		Boolean roundRect = FlatUIUtils.isRoundRect( c );
+		return roundRect != null ? (roundRect ? Short.MAX_VALUE : 0) : arc;
 	}
 }

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

@@ -19,15 +19,16 @@ package com.formdev.flatlaf.ui;
 import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.Graphics;
+import java.awt.Insets;
 import java.awt.Rectangle;
 import java.awt.event.MouseAdapter;
 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.JScrollBar;
 import javax.swing.JScrollPane;
 import javax.swing.SwingUtilities;
 import javax.swing.UIManager;
@@ -52,29 +53,49 @@ import com.formdev.flatlaf.util.UIScale;
  *
  * <!-- FlatScrollBarUI -->
  *
- * @uiDefault ScrollBar.hoverTrackColor				Color
- * @uiDefault ScrollBar.hoverThumbColor				Color
- * @uiDefault Component.arrowType					String	triangle (default) or chevron
+ * @uiDefault ScrollBar.trackInsets					Insets
+ * @uiDefault ScrollBar.thumbInsets					Insets
+ * @uiDefault ScrollBar.trackArc					int
+ * @uiDefault ScrollBar.thumbArc					int
+ * @uiDefault ScrollBar.hoverTrackColor				Color	optional
+ * @uiDefault ScrollBar.hoverThumbColor				Color	optional
+ * @uiDefault ScrollBar.hoverThumbWithTrack			boolean
+ * @uiDefault ScrollBar.pressedTrackColor			Color	optional
+ * @uiDefault ScrollBar.pressedThumbColor			Color	optional
+ * @uiDefault ScrollBar.pressedThumbWithTrack		boolean
+ * @uiDefault Component.arrowType					String	chevron (default) or triangle
  * @uiDefault ScrollBar.showButtons					boolean
  * @uiDefault ScrollBar.buttonArrowColor			Color
  * @uiDefault ScrollBar.buttonDisabledArrowColor	Color
+ * @uiDefault ScrollBar.hoverButtonBackground		Color	optional
+ * @uiDefault ScrollBar.pressedButtonBackground		Color	optional
  *
  * @author Karl Tauber
  */
 public class FlatScrollBarUI
 	extends BasicScrollBarUI
 {
+	protected Insets trackInsets;
+	protected Insets thumbInsets;
+	protected int trackArc;
+	protected int thumbArc;
 	protected Color hoverTrackColor;
 	protected Color hoverThumbColor;
+	protected boolean hoverThumbWithTrack;
+	protected Color pressedTrackColor;
+	protected Color pressedThumbColor;
+	protected boolean pressedThumbWithTrack;
 
 	protected boolean showButtons;
 	protected String arrowType;
 	protected Color buttonArrowColor;
 	protected Color buttonDisabledArrowColor;
+	protected Color hoverButtonBackground;
+	protected Color pressedButtonBackground;
 
 	private MouseAdapter hoverListener;
-	private boolean hoverTrack;
-	private boolean hoverThumb;
+	protected boolean hoverTrack;
+	protected boolean hoverThumb;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatScrollBarUI();
@@ -102,52 +123,72 @@ public class FlatScrollBarUI
 	protected void installDefaults() {
 		super.installDefaults();
 
+		trackInsets = UIManager.getInsets( "ScrollBar.trackInsets" );
+		thumbInsets = UIManager.getInsets( "ScrollBar.thumbInsets" );
+		trackArc = UIManager.getInt( "ScrollBar.trackArc" );
+		thumbArc = UIManager.getInt( "ScrollBar.thumbArc" );
 		hoverTrackColor = UIManager.getColor( "ScrollBar.hoverTrackColor" );
 		hoverThumbColor = UIManager.getColor( "ScrollBar.hoverThumbColor" );
+		hoverThumbWithTrack = UIManager.getBoolean( "ScrollBar.hoverThumbWithTrack" );
+		pressedTrackColor = UIManager.getColor( "ScrollBar.pressedTrackColor" );
+		pressedThumbColor = UIManager.getColor( "ScrollBar.pressedThumbColor" );
+		pressedThumbWithTrack = UIManager.getBoolean( "ScrollBar.pressedThumbWithTrack" );
 
 		showButtons = UIManager.getBoolean( "ScrollBar.showButtons" );
 		arrowType = UIManager.getString( "Component.arrowType" );
 		buttonArrowColor = UIManager.getColor( "ScrollBar.buttonArrowColor" );
 		buttonDisabledArrowColor = UIManager.getColor( "ScrollBar.buttonDisabledArrowColor" );
+		hoverButtonBackground = UIManager.getColor( "ScrollBar.hoverButtonBackground" );
+		pressedButtonBackground = UIManager.getColor( "ScrollBar.pressedButtonBackground" );
+
+		// fallback (e.g. when used in NetBeans GUI builder)
+		if( trackInsets == null )
+			trackInsets = new Insets( 0, 0, 0, 0 );
+		if( thumbInsets == null )
+			thumbInsets = new Insets( 0, 0, 0, 0 );
 	}
 
 	@Override
 	protected void uninstallDefaults() {
 		super.uninstallDefaults();
 
+		trackInsets = null;
+		thumbInsets = null;
 		hoverTrackColor = null;
 		hoverThumbColor = null;
+		pressedTrackColor = null;
+		pressedThumbColor = null;
 
 		buttonArrowColor = null;
 		buttonDisabledArrowColor = null;
+		hoverButtonBackground = null;
+		pressedButtonBackground = null;
 	}
 
 	@Override
 	protected PropertyChangeListener createPropertyChangeListener() {
-		return new BasicScrollBarUI.PropertyChangeHandler() {
-			@Override
-			public void propertyChange( PropertyChangeEvent e ) {
-				super.propertyChange( e );
+		PropertyChangeListener superListener = super.createPropertyChangeListener();
+		return e -> {
+			superListener.propertyChange( e );
 
-				switch( e.getPropertyName() ) {
-					case FlatClientProperties.SCROLL_BAR_SHOW_BUTTONS:
-						scrollbar.revalidate();
-						scrollbar.repaint();
-						break;
+			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;
-							}
+				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;
-				}
+					}
+					SwingUtilities.replaceUIInputMap( scrollbar, JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, inputMap );
+					break;
 			}
 		};
 	}
@@ -159,50 +200,62 @@ public class FlatScrollBarUI
 
 	@Override
 	protected JButton createDecreaseButton( int orientation ) {
-		return createArrowButton( orientation );
+		return new FlatScrollBarButton( orientation );
 	}
 
 	@Override
 	protected JButton createIncreaseButton( int orientation ) {
-		return createArrowButton( orientation );
+		return new FlatScrollBarButton( orientation );
 	}
 
-	private JButton createArrowButton( int orientation ) {
-		FlatArrowButton button = new FlatArrowButton( orientation,
-			arrowType, buttonArrowColor, buttonDisabledArrowColor, null, hoverTrackColor )
-		{
-			@Override
-			public Dimension getPreferredSize() {
-				if( isShowButtons() ) {
-					int w = UIScale.scale( scrollBarWidth );
-					return new Dimension( w, w );
-				} else
-					return new Dimension();
-			}
-
-			@Override
-			public Dimension getMinimumSize() {
-				return isShowButtons() ? super.getMinimumSize() : new Dimension();
-			}
-
-			@Override
-			public Dimension getMaximumSize() {
-				return isShowButtons() ? super.getMaximumSize() : new Dimension();
-			}
-		};
-		button.setArrowWidth( FlatArrowButton.DEFAULT_ARROW_WIDTH - 2 );
-		button.setFocusable( false );
-		button.setRequestFocusEnabled( false );
-		return button;
-	}
-
-	private boolean isShowButtons() {
+	protected boolean isShowButtons() {
 		Object showButtons = scrollbar.getClientProperty( FlatClientProperties.SCROLL_BAR_SHOW_BUTTONS );
 		if( showButtons == null && scrollbar.getParent() instanceof JScrollPane )
 			showButtons = ((JScrollPane)scrollbar.getParent()).getClientProperty( FlatClientProperties.SCROLL_BAR_SHOW_BUTTONS );
 		return (showButtons != null) ? Objects.equals( showButtons, true ) : this.showButtons;
 	}
 
+	@Override
+	public void paint( Graphics g, JComponent c ) {
+		Object[] oldRenderingHints = FlatUIUtils.setRenderingHints( g );
+		super.paint( g, c );
+		FlatUIUtils.resetRenderingHints( g, oldRenderingHints );
+	}
+
+	@Override
+	protected void paintTrack( Graphics g, JComponent c, Rectangle trackBounds ) {
+		g.setColor( getTrackColor( c, hoverTrack, isPressed && hoverTrack && !hoverThumb ) );
+		paintTrackOrThumb( g, c, trackBounds, trackInsets, trackArc );
+	}
+
+	@Override
+	protected void paintThumb( Graphics g, JComponent c, Rectangle thumbBounds ) {
+		if( thumbBounds.isEmpty() || !scrollbar.isEnabled() )
+			return;
+
+		g.setColor( getThumbColor( c, hoverThumb || (hoverThumbWithTrack && hoverTrack),
+			isPressed && (hoverThumb || (pressedThumbWithTrack && hoverTrack)) ) );
+		paintTrackOrThumb( g, c, thumbBounds, thumbInsets, thumbArc );
+	}
+
+	protected void paintTrackOrThumb( Graphics g, JComponent c, Rectangle bounds, Insets insets, int arc ) {
+		// rotate insets for horizontal orientation because they are given for vertical orientation
+		if( scrollbar.getOrientation() == JScrollBar.HORIZONTAL )
+			insets = new Insets( insets.right, insets.top, insets.left, insets.bottom );
+
+		// subtract insets from bounds
+		bounds = FlatUIUtils.subtractInsets( bounds, UIScale.scale( insets ) );
+
+		if( arc <= 0 ) {
+			// paint rectangle
+			g.fillRect( bounds.x, bounds.y, bounds.width, bounds.height );
+		} else {
+			// paint round rectangle
+			arc = Math.min( UIScale.scale( arc ), Math.min( bounds.width, bounds.height ) );
+			g.fillRoundRect( bounds.x, bounds.y, bounds.width, bounds.height, arc, arc );
+		}
+	}
+
 	@Override
 	protected void paintDecreaseHighlight( Graphics g ) {
 		// do not paint
@@ -213,29 +266,33 @@ public class FlatScrollBarUI
 		// do not paint
 	}
 
-	@Override
-	protected void paintTrack( Graphics g, JComponent c, Rectangle trackBounds ) {
-		g.setColor( hoverTrack ? hoverTrackColor : trackColor );
-		g.fillRect( trackBounds.x, trackBounds.y, trackBounds.width, trackBounds.height );
+	protected Color getTrackColor( JComponent c, boolean hover, boolean pressed ) {
+		Color trackColor = FlatUIUtils.deriveColor( this.trackColor, c.getBackground() );
+		return (pressed && pressedTrackColor != null)
+			? FlatUIUtils.deriveColor( pressedTrackColor, trackColor )
+			: ((hover && hoverTrackColor != null)
+				? FlatUIUtils.deriveColor( hoverTrackColor, trackColor )
+				: trackColor);
 	}
 
-	@Override
-	protected void paintThumb( Graphics g, JComponent c, Rectangle thumbBounds ) {
-		if( thumbBounds.isEmpty() || !scrollbar.isEnabled() )
-			return;
-
-		g.setColor( hoverThumb ? hoverThumbColor : thumbColor );
-		g.fillRect( thumbBounds.x, thumbBounds.y, thumbBounds.width, thumbBounds.height );
+	protected Color getThumbColor( JComponent c, boolean hover, boolean pressed ) {
+		Color trackColor = FlatUIUtils.deriveColor( this.trackColor, c.getBackground() );
+		Color thumbColor = FlatUIUtils.deriveColor( this.thumbColor, trackColor );
+		return (pressed && pressedThumbColor != null)
+			? FlatUIUtils.deriveColor( pressedThumbColor, thumbColor )
+			: ((hover && hoverThumbColor != null)
+				? FlatUIUtils.deriveColor( hoverThumbColor, thumbColor )
+				: thumbColor);
 	}
 
 	@Override
 	protected Dimension getMinimumThumbSize() {
-		return UIScale.scale( super.getMinimumThumbSize() );
+		return UIScale.scale( FlatUIUtils.addInsets( super.getMinimumThumbSize(), thumbInsets ) );
 	}
 
 	@Override
 	protected Dimension getMaximumThumbSize() {
-		return UIScale.scale( super.getMaximumThumbSize() );
+		return UIScale.scale( FlatUIUtils.addInsets( super.getMaximumThumbSize(), thumbInsets ) );
 	}
 
 	//---- class ScrollBarHoverListener ---------------------------------------
@@ -263,11 +320,14 @@ public class FlatScrollBarUI
 		@Override
 		public void mousePressed( MouseEvent e ) {
 			isPressed = true;
+			repaint();
 		}
 
 		@Override
 		public void mouseReleased( MouseEvent e ) {
 			isPressed = false;
+			repaint();
+
 			update( e.getX(), e.getY() );
 		}
 
@@ -286,4 +346,50 @@ public class FlatScrollBarUI
 				scrollbar.repaint();
 		}
 	}
+
+	//---- class FlatScrollBarButton ------------------------------------------
+
+	protected class FlatScrollBarButton
+		extends FlatArrowButton
+	{
+		protected FlatScrollBarButton( int direction ) {
+			this( direction, arrowType, buttonArrowColor, buttonDisabledArrowColor,
+				null, hoverButtonBackground, null, pressedButtonBackground );
+		}
+
+		protected FlatScrollBarButton( int direction, String type, Color foreground, Color disabledForeground,
+			Color hoverForeground, Color hoverBackground, Color pressedForeground, Color pressedBackground )
+		{
+			super( direction, type, foreground, disabledForeground,
+				hoverForeground, hoverBackground, pressedForeground, pressedBackground );
+
+			setArrowWidth( FlatArrowButton.DEFAULT_ARROW_WIDTH - 2 );
+			setFocusable( false );
+			setRequestFocusEnabled( false );
+		}
+
+		@Override
+		protected Color deriveBackground( Color background ) {
+			return FlatUIUtils.deriveColor( background, scrollbar.getBackground() );
+		}
+
+		@Override
+		public Dimension getPreferredSize() {
+			if( isShowButtons() ) {
+				int w = UIScale.scale( scrollBarWidth );
+				return new Dimension( w, w );
+			} else
+				return new Dimension();
+		}
+
+		@Override
+		public Dimension getMinimumSize() {
+			return isShowButtons() ? super.getMinimumSize() : new Dimension();
+		}
+
+		@Override
+		public Dimension getMaximumSize() {
+			return isShowButtons() ? super.getMaximumSize() : new Dimension();
+		}
+	}
 }

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

@@ -14,17 +14,12 @@
  * 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.KeyboardFocusManager;
 import java.awt.Rectangle;
 import java.awt.event.ContainerEvent;
 import java.awt.event.ContainerListener;
@@ -40,11 +35,13 @@ import javax.swing.JComponent;
 import javax.swing.JScrollBar;
 import javax.swing.JScrollPane;
 import javax.swing.JTable;
+import javax.swing.JTree;
 import javax.swing.JViewport;
 import javax.swing.LookAndFeel;
 import javax.swing.ScrollPaneConstants;
 import javax.swing.Scrollable;
 import javax.swing.SwingConstants;
+import javax.swing.SwingUtilities;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicScrollPaneUI;
@@ -83,7 +80,7 @@ public class FlatScrollPaneUI
 		int focusWidth = UIManager.getInt( "Component.focusWidth" );
 		LookAndFeel.installProperty( c, "opaque", focusWidth == 0 );
 
-		MigLayoutVisualPadding.install( scrollpane, focusWidth );
+		MigLayoutVisualPadding.install( scrollpane );
 	}
 
 	@Override
@@ -111,26 +108,30 @@ public class FlatScrollPaneUI
 
 	@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 );
-			}
+		MouseWheelListener superListener = super.createMouseWheelListener();
+		return e -> {
+			if( isSmoothScrollingEnabled() &&
+				scrollpane.isWheelScrollingEnabled() &&
+				e.getScrollType() == MouseWheelEvent.WHEEL_UNIT_SCROLL &&
+				e.getPreciseWheelRotation() != 0 &&
+				e.getPreciseWheelRotation() != e.getWheelRotation() )
+			{
+				mouseWheelMovedSmooth( e );
+			} else
+				superListener.mouseWheelMoved( e );
 		};
 	}
 
-	private static final double EPSILON = 1e-5d;
+	protected boolean isSmoothScrollingEnabled() {
+		Object smoothScrolling = scrollpane.getClientProperty( FlatClientProperties.SCROLL_PANE_SMOOTH_SCROLLING );
+		if( smoothScrolling instanceof Boolean )
+			return (Boolean) smoothScrolling;
+
+		// 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).
+		return UIManager.getBoolean( "ScrollPane.smoothScrolling" );
+	}
 
 	private void mouseWheelMovedSmooth( MouseWheelEvent e ) {
 		// return if there is no viewport
@@ -152,24 +153,22 @@ public class FlatScrollPaneUI
 		// get precise wheel rotation
 		double rotation = e.getPreciseWheelRotation();
 
-		// get unit and block increment
+		// get unit 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).
+			// Use (0, 0) view position to obtain a constant unit increment of first item.
+			// Unit increment may be different for each item.
 			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.
+				// than the other items (e.g. themes list in FlatLaf Demo),
+				// get the unit increment of the second item and use the smaller one.
 				if( orientation == SwingConstants.VERTICAL ) {
 					visibleRect.y += unitIncrement;
 					visibleRect.height -= unitIncrement;
@@ -184,92 +183,96 @@ public class FlatScrollPaneUI
 		} 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();
+		// get viewport width/height (the visible width/height)
 		int viewportWH = (orientation == SwingConstants.VERTICAL)
 			? viewport.getHeight()
 			: viewport.getWidth();
-		if( unitIncrement * scrollAmount > viewportWH )
-			scrollAmount = Math.max( viewportWH / unitIncrement, 1 );
+
+		// limit scroll increment to viewport width/height
+		// - if scroll amount is set to a large value in OS settings
+		// - for large unit increments in small viewports (e.g. horizontal scrolling in file chooser)
+		int scrollIncrement = Math.min( unitIncrement * e.getScrollAmount(), viewportWH );
 
 		// 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;
+		double delta = rotation * scrollIncrement;
+		int idelta = (int) Math.round( delta );
+
+		// scroll at least one pixel to avoid "hanging"
+		// - for "super-low-speed" scrolling (move fingers very slowly on trackpad)
+		// - if unit increment is very small (e.g. 1 if scroll view does not implement
+		//   javax.swing.Scrollable interface)
+		if( idelta == 0 ) {
+			if( rotation > 0 )
+				idelta = 1;
+			else if( rotation < 0 )
+				idelta = -1;
+		}
 
 		// 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 );
+		int minValue = scrollbar.getMinimum();
+		int maxValue = scrollbar.getMaximum() - scrollbar.getModel().getExtent();
+		int newValue = Math.max( minValue, Math.min( value + idelta, maxValue ) );
 
 		// 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",
+		System.out.println( String.format( "%s  %4d  %9f  /  %3d * %d = %3d  [%3d]  /  %8.2f %5d  /  %4d --> %4d  [%d, %d]",
+			(orientation == SwingConstants.VERTICAL) ? "V" : "H",
 			e.getWheelRotation(),
 			e.getPreciseWheelRotation(),
 			unitIncrement,
-			blockIncrement,
+			e.getScrollAmount(),
+			scrollIncrement,
+			viewportWH,
 			delta,
-			adjustDelta,
-			adjustedDelta,
+			idelta,
 			value,
-			scrollbar.getMinimum(),
-			scrollbar.getMaximum(),
-			minDelta,
-			maxDelta,
-			boundedDelta,
-			newValue ) );
+			newValue,
+			minValue,
+			maxValue ) );
 */
 	}
 
 	@Override
 	protected PropertyChangeListener createPropertyChangeListener() {
-		return new BasicScrollPaneUI.PropertyChangeHandler() {
-			@Override
-			public void propertyChange( PropertyChangeEvent e ) {
-				super.propertyChange( e );
+		PropertyChangeListener superListener = super.createPropertyChangeListener();
+		return e -> {
+			superListener.propertyChange( e );
 
-				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 );
-						}
+			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;
 			}
 		};
 	}
@@ -329,6 +332,31 @@ public class FlatScrollPaneUI
 		paint( g, c );
 	}
 
+	/**
+	 * @since 1.3
+	 */
+	public static boolean isPermanentFocusOwner( JScrollPane scrollPane ) {
+		JViewport viewport = scrollPane.getViewport();
+		Component view = (viewport != null) ? viewport.getView() : null;
+		if( view == null )
+			return false;
+
+		// check whether view is focus owner
+		if( FlatUIUtils.isPermanentFocusOwner( view ) )
+			return true;
+
+		// check whether editor component in JTable or JTree is focus owner
+		if( (view instanceof JTable && ((JTable)view).isEditing()) ||
+			(view instanceof JTree && ((JTree)view).isEditing()) )
+		{
+			Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
+			if( focusOwner != null )
+				return SwingUtilities.isDescendingFrom( focusOwner, view );
+		}
+
+		return false;
+	}
+
 	//---- class Handler ------------------------------------------------------
 
 	/**
@@ -350,11 +378,13 @@ public class FlatScrollPaneUI
 
 		@Override
 		public void focusGained( FocusEvent e ) {
+			// necessary to update focus border
 			scrollpane.repaint();
 		}
 
 		@Override
 		public void focusLost( FocusEvent e ) {
+			// necessary to update focus border
 			scrollpane.repaint();
 		}
 	}

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

@@ -52,12 +52,8 @@ public class FlatSeparatorUI
 
 	private boolean defaults_initialized = false;
 
-	private static ComponentUI instance;
-
 	public static ComponentUI createUI( JComponent c ) {
-		if( instance == null )
-			instance = new FlatSeparatorUI();
-		return instance;
+		return FlatUIUtils.createSharedUI( FlatSeparatorUI.class, FlatSeparatorUI::new );
 	}
 
 	@Override

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

@@ -18,17 +18,25 @@ package com.formdev.flatlaf.ui;
 
 import java.awt.Color;
 import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.FontMetrics;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
-import java.awt.event.MouseListener;
+import java.awt.Insets;
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.awt.event.MouseEvent;
+import java.awt.geom.Ellipse2D;
 import java.awt.geom.Path2D;
 import java.awt.geom.RoundRectangle2D;
 import javax.swing.JComponent;
 import javax.swing.JSlider;
 import javax.swing.LookAndFeel;
+import javax.swing.SwingUtilities;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicSliderUI;
+import com.formdev.flatlaf.util.HiDPIUtils;
 import com.formdev.flatlaf.util.UIScale;
 
 /**
@@ -49,29 +57,49 @@ import com.formdev.flatlaf.util.UIScale;
  * <!-- FlatSliderUI -->
  *
  * @uiDefault Slider.trackWidth				int
- * @uiDefault Slider.thumbWidth				int
+ * @uiDefault Slider.thumbSize				Dimension
+ * @uiDefault Slider.focusWidth				int
+ * @uiDefault Slider.trackValueColor		Color	optional; defaults to Slider.thumbColor
  * @uiDefault Slider.trackColor				Color
  * @uiDefault Slider.thumbColor				Color
+ * @uiDefault Slider.thumbBorderColor		Color	optional; if null, no border is painted
  * @uiDefault Slider.focusedColor			Color	optional; defaults to Component.focusColor
- * @uiDefault Slider.hoverColor				Color	optional; defaults to Slider.focusedColor
- * @uiDefault Slider.disabledForeground		Color	used for track and thumb is disabled
+ * @uiDefault Slider.focusedThumbBorderColor Color	optional; defaults to Component.focusedBorderColor
+ * @uiDefault Slider.hoverThumbColor		Color	optional
+ * @uiDefault Slider.pressedThumbColor		Color	optional
+ * @uiDefault Slider.disabledTrackColor		Color
+ * @uiDefault Slider.disabledThumbColor		Color
+ * @uiDefault Slider.disabledThumbBorderColor Color	optional; defaults to Component.disabledBorderColor
  *
  * @author Karl Tauber
  */
 public class FlatSliderUI
 	extends BasicSliderUI
 {
-	private int trackWidth;
-	private int thumbWidth;
+	protected int trackWidth;
+	protected Dimension thumbSize;
+	protected int focusWidth;
 
-	private Color trackColor;
-	private Color thumbColor;
-	private Color focusColor;
-	private Color hoverColor;
-	private Color disabledForeground;
+	protected Color trackValueColor;
+	protected Color trackColor;
+	protected Color thumbColor;
+	protected Color thumbBorderColor;
+	protected Color focusBaseColor;
+	protected Color focusedColor;
+	protected Color focusedThumbBorderColor;
+	protected Color hoverThumbColor;
+	protected Color pressedThumbColor;
+	protected Color disabledTrackColor;
+	protected Color disabledThumbColor;
+	protected Color disabledThumbBorderColor;
 
-	private MouseListener hoverListener;
-	private boolean hover;
+	private Color defaultBackground;
+	private Color defaultForeground;
+
+	protected boolean thumbHover;
+	protected boolean thumbPressed;
+
+	private Object[] oldRenderingHints;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatSliderUI();
@@ -81,24 +109,6 @@ public class FlatSliderUI
 		super( null );
 	}
 
-	@Override
-	protected void installListeners( JSlider slider ) {
-		super.installListeners( slider );
-
-		hoverListener = new FlatUIUtils.HoverListener( slider, h -> {
-			hover = h;
-		} );
-		slider.addMouseListener( hoverListener );
-	}
-
-	@Override
-	protected void uninstallListeners( JSlider slider ) {
-		super.uninstallListeners( slider );
-
-		slider.removeMouseListener( hoverListener );
-		hoverListener = null;
-	}
-
 	@Override
 	protected void installDefaults( JSlider slider ) {
 		super.installDefaults( slider );
@@ -106,24 +116,89 @@ public class FlatSliderUI
 		LookAndFeel.installProperty( slider, "opaque", false );
 
 		trackWidth = UIManager.getInt( "Slider.trackWidth" );
-		thumbWidth = UIManager.getInt( "Slider.thumbWidth" );
+		thumbSize = UIManager.getDimension( "Slider.thumbSize" );
+		if( thumbSize == null ) {
+			// fallback for compatibility with old versions
+			int thumbWidth = UIManager.getInt( "Slider.thumbWidth" );
+			thumbSize = new Dimension( thumbWidth, thumbWidth );
+		}
+		focusWidth = FlatUIUtils.getUIInt( "Slider.focusWidth", 4 );
 
+		trackValueColor = FlatUIUtils.getUIColor( "Slider.trackValueColor", "Slider.thumbColor" );
 		trackColor = UIManager.getColor( "Slider.trackColor" );
 		thumbColor = UIManager.getColor( "Slider.thumbColor" );
-		focusColor = FlatUIUtils.getUIColor( "Slider.focusedColor", "Component.focusColor" );
-		hoverColor = FlatUIUtils.getUIColor( "Slider.hoverColor", focusColor );
-		disabledForeground = UIManager.getColor( "Slider.disabledForeground" );
+		thumbBorderColor = UIManager.getColor( "Slider.thumbBorderColor" );
+		focusBaseColor = UIManager.getColor( "Component.focusColor" );
+		focusedColor = FlatUIUtils.getUIColor( "Slider.focusedColor", focusBaseColor );
+		focusedThumbBorderColor = FlatUIUtils.getUIColor( "Slider.focusedThumbBorderColor", "Component.focusedBorderColor" );
+		hoverThumbColor = UIManager.getColor( "Slider.hoverThumbColor" );
+		pressedThumbColor = UIManager.getColor( "Slider.pressedThumbColor" );
+		disabledTrackColor = UIManager.getColor( "Slider.disabledTrackColor" );
+		disabledThumbColor = UIManager.getColor( "Slider.disabledThumbColor" );
+		disabledThumbBorderColor = FlatUIUtils.getUIColor( "Slider.disabledThumbBorderColor", "Component.disabledBorderColor" );
+
+		defaultBackground = UIManager.getColor( "Slider.background" );
+		defaultForeground = UIManager.getColor( "Slider.foreground" );
 	}
 
 	@Override
 	protected void uninstallDefaults( JSlider slider ) {
 		super.uninstallDefaults( slider );
 
+		trackValueColor = null;
 		trackColor = null;
 		thumbColor = null;
-		focusColor = null;
-		hoverColor = null;
-		disabledForeground = null;
+		thumbBorderColor = null;
+		focusBaseColor = null;
+		focusedColor = null;
+		focusedThumbBorderColor = null;
+		hoverThumbColor = null;
+		pressedThumbColor = null;
+		disabledTrackColor = null;
+		disabledThumbColor = null;
+		disabledThumbBorderColor = null;
+
+		defaultBackground = null;
+		defaultForeground = null;
+	}
+
+	@Override
+	protected TrackListener createTrackListener( JSlider slider ) {
+		return new FlatTrackListener();
+	}
+
+	@Override
+	public int getBaseline( JComponent c, int width, int height ) {
+		if( c == null )
+			throw new NullPointerException();
+		if( width < 0 || height < 0 )
+			throw new IllegalArgumentException();
+
+		// no baseline for vertical orientation
+		if( slider.getOrientation() == JSlider.VERTICAL )
+			return -1;
+
+		// use default font (instead of slider font) because the slider font size
+		// may be different to label font size, but we want align the track/thumb with labels
+		Font font = UIManager.getFont( "defaultFont" );
+		if( font == null )
+			font = slider.getFont();
+		FontMetrics fm = slider.getFontMetrics( font );
+
+		// calculate track y coordinate and height
+		// (not using field trackRect here because slider size may be [0,0]
+		// and field trackRect may have invalid values in this case)
+		Insets insets = slider.getInsets();
+		int thumbHeight = getThumbSize().height;
+		int contentHeight = height - insets.top - insets.bottom - focusInsets.top - focusInsets.bottom;
+		int centerSpacing = thumbHeight
+			+ (slider.getPaintTicks() ? getTickLength() : 0)
+			+ (slider.getPaintLabels() ? getHeightOfTallestLabel() : 0);
+		int trackY = insets.top + focusInsets.top + (contentHeight - centerSpacing - 1) / 2;
+		int trackHeight = thumbHeight;
+
+		// compute a baseline so that the track is vertically centered
+		return trackY + Math.round( (trackHeight - fm.getHeight()) / 2f ) + fm.getAscent() - 1;
 	}
 
 	@Override
@@ -153,14 +228,50 @@ public class FlatSliderUI
 
 	@Override
 	protected Dimension getThumbSize() {
-		return new Dimension( UIScale.scale( thumbWidth ), UIScale.scale( thumbWidth ) );
+		return calcThumbSize( slider, thumbSize, focusWidth );
+	}
+
+	public static Dimension calcThumbSize( JSlider slider, Dimension thumbSize, int focusWidth ) {
+		int fw = UIScale.scale( focusWidth );
+		int w = UIScale.scale( thumbSize.width ) + fw + fw;
+		int h = UIScale.scale( thumbSize.height ) + fw + fw;
+		return (slider.getOrientation() == JSlider.HORIZONTAL)
+			? new Dimension( w, h )
+			: new Dimension( h, w );
 	}
 
 	@Override
 	public void paint( Graphics g, JComponent c ) {
-		FlatUIUtils.setRenderingHints( (Graphics2D) g );
+		oldRenderingHints = FlatUIUtils.setRenderingHints( g );
+
+/*debug
+		g.setColor( Color.gray );
+		g.drawRect( 0, 0, c.getWidth() - 1, c.getHeight() - 1 );
+		g.setColor( Color.orange );
+		g.drawRect( focusRect.x, focusRect.y, focusRect.width - 1, focusRect.height - 1 );
+		g.setColor( Color.magenta );
+		g.drawRect( contentRect.x, contentRect.y, contentRect.width - 1, contentRect.height - 1 );
+		g.setColor( Color.blue );
+		g.drawRect( trackRect.x, trackRect.y, trackRect.width - 1, trackRect.height - 1 );
+		g.setColor( Color.red );
+		g.drawRect( thumbRect.x, thumbRect.y, thumbRect.width - 1, thumbRect.height - 1 );
+		g.setColor( Color.green );
+		g.drawRect( tickRect.x, tickRect.y, tickRect.width - 1, tickRect.height - 1 );
+		g.setColor( Color.red );
+		g.drawRect( labelRect.x, labelRect.y, labelRect.width - 1, labelRect.height - 1 );
+debug*/
 
 		super.paint( g, c );
+
+		FlatUIUtils.resetRenderingHints( g, oldRenderingHints );
+		oldRenderingHints = null;
+	}
+
+	@Override
+	public void paintLabels( Graphics g ) {
+		FlatUIUtils.runWithoutRenderingHints( g, oldRenderingHints, () -> {
+			super.paintLabels( g );
+		} );
 	}
 
 	@Override
@@ -201,50 +312,326 @@ public class FlatSliderUI
 		}
 
 		if( coloredTrack != null ) {
-			FlatUIUtils.setColor( g, slider.hasFocus() ? focusColor : (hover ? hoverColor : thumbColor), thumbColor );
+			if( slider.getInverted() ) {
+				RoundRectangle2D temp = track;
+				track = coloredTrack;
+				coloredTrack = temp;
+			}
+
+			g.setColor( getTrackValueColor() );
 			((Graphics2D)g).fill( coloredTrack );
 		}
 
-		g.setColor( enabled ? trackColor : disabledForeground );
+		g.setColor( enabled ? getTrackColor() : disabledTrackColor );
 		((Graphics2D)g).fill( track );
 	}
 
 	@Override
 	public void paintThumb( Graphics g ) {
-		FlatUIUtils.setColor( g, slider.isEnabled()
-			? (slider.hasFocus() ? focusColor : (hover ? hoverColor : thumbColor))
-			: disabledForeground,
-			thumbColor );
+		Color thumbColor = getThumbColor();
+		Color color = stateColor( slider, thumbHover, thumbPressed,
+			thumbColor, disabledThumbColor, null, hoverThumbColor, pressedThumbColor );
+		color = FlatUIUtils.deriveColor( color, thumbColor );
 
-		if( isRoundThumb() )
-			g.fillOval( thumbRect.x, thumbRect.y, thumbRect.width, thumbRect.height );
-		else {
-			double w = thumbRect.width;
-			double h = thumbRect.height;
-			double wh = w / 2;
+		Color foreground = slider.getForeground();
+		Color borderColor = (thumbBorderColor != null && foreground == defaultForeground)
+			? stateColor( slider, false, false, thumbBorderColor, disabledThumbBorderColor, focusedThumbBorderColor, null, null )
+			: null;
 
-			Path2D thumb = FlatUIUtils.createPath( 0,0, w,0, w,(h - wh), wh,h,  0,(h - wh) );
+		Color focusedColor = FlatUIUtils.deriveColor( this.focusedColor,
+			(foreground != defaultForeground) ? foreground : focusBaseColor );
 
+		paintThumb( g, slider, thumbRect, isRoundThumb(), color, borderColor, focusedColor, focusWidth );
+	}
+
+	public static void paintThumb( Graphics g, JSlider slider, Rectangle thumbRect, boolean roundThumb,
+		Color thumbColor, Color thumbBorderColor, Color focusedColor, int focusWidth )
+	{
+		double systemScaleFactor = UIScale.getSystemScaleFactor( (Graphics2D) 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( (Graphics2D) g, thumbRect.x, thumbRect.y, thumbRect.width, thumbRect.height,
+				(g2d, x2, y2, width2, height2, scaleFactor) -> {
+					paintThumbImpl( g, slider, x2, y2, width2, height2,
+						roundThumb, thumbColor, thumbBorderColor, focusedColor,
+						(float) (focusWidth * scaleFactor) );
+				} );
+			return;
+		}
+
+		paintThumbImpl( g, slider, thumbRect.x, thumbRect.y, thumbRect.width, thumbRect.height,
+			roundThumb, thumbColor, thumbBorderColor, focusedColor, focusWidth );
+
+	}
+
+	private static void paintThumbImpl( Graphics g, JSlider slider, int x, int y, int width, int height,
+		boolean roundThumb, Color thumbColor, Color thumbBorderColor, Color focusedColor, float focusWidth )
+	{
+		int fw = Math.round( UIScale.scale( focusWidth ) );
+		int tx = x + fw;
+		int ty = y + fw;
+		int tw = width - fw - fw;
+		int th = height - fw - fw;
+		boolean focused = FlatUIUtils.isPermanentFocusOwner( slider );
+
+		if( roundThumb ) {
+			// paint thumb focus border
+			if( focused ) {
+				g.setColor( focusedColor );
+				((Graphics2D)g).fill( createRoundThumbShape( x, y, width, height ) );
+			}
+
+			if( thumbBorderColor != null ) {
+				// paint thumb border
+				g.setColor( thumbBorderColor );
+				((Graphics2D)g).fill( createRoundThumbShape( tx, ty, tw, th ) );
+
+				// paint thumb background
+				float lw = UIScale.scale( 1f );
+				g.setColor( thumbColor );
+				((Graphics2D)g).fill( createRoundThumbShape( tx + lw, ty + lw,
+					tw - lw - lw, th - lw - lw ) );
+			} else {
+				// paint thumb background
+				g.setColor( thumbColor );
+				((Graphics2D)g).fill( createRoundThumbShape( tx, ty, tw, th ) );
+			}
+		} else {
 			Graphics2D g2 = (Graphics2D) g.create();
 			try {
-				g2.translate( thumbRect.x, thumbRect.y );
+				g2.translate( x, y );
 				if( slider.getOrientation() == JSlider.VERTICAL ) {
 					if( slider.getComponentOrientation().isLeftToRight() ) {
-						g2.translate( 0, thumbRect.height );
+						g2.translate( 0, height );
 						g2.rotate( Math.toRadians( 270 ) );
 					} else {
-						g2.translate( thumbRect.width, 0 );
+						g2.translate( width, 0 );
 						g2.rotate( Math.toRadians( 90 ) );
 					}
+
+					// rotate thumb width/height
+					int temp = tw;
+					tw = th;
+					th = temp;
+				}
+
+				// paint thumb focus border
+				if( focused ) {
+					g2.setColor( focusedColor );
+					g2.fill( createDirectionalThumbShape( 0, 0,
+						tw + fw + fw, th + fw + fw + (fw * 0.4142f), fw ) );
+				}
+
+				if( thumbBorderColor != null ) {
+					// paint thumb border
+					g2.setColor( thumbBorderColor );
+					g2.fill( createDirectionalThumbShape( fw, fw, tw, th, 0 ) );
+
+					// paint thumb background
+					float lw = UIScale.scale( 1f );
+					g2.setColor( thumbColor );
+					g2.fill( createDirectionalThumbShape( fw + lw, fw + lw,
+						tw - lw - lw, th - lw - lw - (lw * 0.4142f), 0 ) );
+				} else {
+					// paint thumb background
+					g2.setColor( thumbColor );
+					g2.fill( createDirectionalThumbShape( fw, fw, tw, th, 0 ) );
 				}
-				g2.fill( thumb );
 			} finally {
 				g2.dispose();
 			}
 		}
 	}
 
-	private boolean isRoundThumb() {
+	public static Shape createRoundThumbShape( float x, float y, float w, float h ) {
+		if( w == h )
+			return new Ellipse2D.Float( x, y, w, h );
+		else {
+			float arc = Math.min( w, h );
+			return new RoundRectangle2D.Float( x, y, w, h, arc, arc );
+		}
+	}
+
+	public static Shape createDirectionalThumbShape( float x, float y, float w, float h, float arc ) {
+		float wh = w / 2;
+
+		Path2D path = new Path2D.Float();
+		path.moveTo( x + wh, y + h );
+		path.lineTo( x, y + (h - wh) );
+		path.lineTo( x, y + arc );
+		path.quadTo( x, y, x + arc, y );
+		path.lineTo( x + (w - arc), y );
+		path.quadTo( x + w, y, x + w, y + arc );
+		path.lineTo( x + w, y + (h - wh) );
+		path.closePath();
+
+		return path;
+	}
+
+	protected Color getTrackValueColor() {
+		Color foreground = slider.getForeground();
+		return (foreground != defaultForeground) ? foreground : trackValueColor;
+	}
+
+	protected Color getTrackColor() {
+		Color backround = slider.getBackground();
+		return (backround != defaultBackground) ? backround : trackColor;
+	}
+
+	protected Color getThumbColor() {
+		Color foreground = slider.getForeground();
+		return (foreground != defaultForeground) ? foreground : thumbColor;
+	}
+
+	public static Color stateColor( JSlider slider, boolean hover, boolean pressed,
+		Color enabledColor, Color disabledColor, Color focusedColor, Color hoverColor, Color pressedColor )
+	{
+		if( disabledColor != null && !slider.isEnabled() )
+			return disabledColor;
+		if( pressedColor != null && pressed )
+			return pressedColor;
+		if( hoverColor != null && hover )
+			return hoverColor;
+		if( focusedColor != null && FlatUIUtils.isPermanentFocusOwner( slider ) )
+			return focusedColor;
+		return enabledColor;
+	}
+
+	protected boolean isRoundThumb() {
 		return !slider.getPaintTicks() && !slider.getPaintLabels();
 	}
+
+	@Override
+	public void setThumbLocation( int x, int y ) {
+		if( !isRoundThumb() ) {
+			// the needle of the directional thumb is painted outside of thumbRect
+			// --> must increase repaint rectangle
+
+			// set new thumb location and compute union of old and new thumb bounds
+			Rectangle r = new Rectangle( thumbRect );
+			thumbRect.setLocation( x, y );
+			SwingUtilities.computeUnion( thumbRect.x, thumbRect.y, thumbRect.width, thumbRect.height, r );
+
+			// increase union rectangle for repaint
+			int extra = (int) Math.ceil( UIScale.scale( focusWidth ) * 0.4142f );
+			if( slider.getOrientation() == JSlider.HORIZONTAL )
+				r.height += extra;
+			else {
+				r.width += extra;
+				if( !slider.getComponentOrientation().isLeftToRight() )
+					r.x -= extra;
+			}
+
+			slider.repaint( r );
+		} else
+			super.setThumbLocation( x, y );
+	}
+
+	//---- class FlatTrackListener --------------------------------------------
+
+	protected class FlatTrackListener
+		extends TrackListener
+	{
+		@Override
+		public void mouseEntered( MouseEvent e ) {
+			setThumbHover( isOverThumb( e ) );
+			super.mouseEntered( e );
+		}
+
+		@Override
+		public void mouseExited( MouseEvent e ) {
+			setThumbHover( false );
+			super.mouseExited( e );
+		}
+
+		@Override
+		public void mouseMoved( MouseEvent e ) {
+			setThumbHover( isOverThumb( e ) );
+			super.mouseMoved( e );
+		}
+
+		@Override
+		public void mousePressed( MouseEvent e ) {
+			setThumbPressed( isOverThumb( e ) );
+
+			if( !slider.isEnabled() )
+				return;
+
+			// use "old" behavior when clicking on track
+			if( UIManager.getBoolean( "Slider.scrollOnTrackClick" ) ) {
+				super.mousePressed( e );
+				return;
+			}
+
+			// "new" behavior set thumb to mouse location when clicking on track
+
+			int x = e.getX();
+			int y = e.getY();
+
+			// clicked on thumb --> let super class do the work
+			calculateGeometry();
+			if( thumbRect.contains( x, y ) ) {
+				super.mousePressed( e );
+				return;
+			}
+
+			if( UIManager.getBoolean( "Slider.onlyLeftMouseButtonDrag" ) &&
+				!SwingUtilities.isLeftMouseButton( e ) )
+			  return;
+
+			// move the mouse event coordinates to the center of the thumb
+			int tx = thumbRect.x + (thumbRect.width / 2) - x;
+			int ty = thumbRect.y + (thumbRect.height / 2) - y;
+			e.translatePoint( tx, ty );
+
+			// invoke super mousePressed() to start dragging thumb
+			super.mousePressed( e );
+
+			// move the mouse event coordinates back to current mouse location
+			e.translatePoint( -tx, -ty );
+
+			// invoke mouseDragged() to update thumb location
+			mouseDragged( e );
+
+			setThumbPressed( true );
+		}
+
+		@Override
+		public void mouseReleased( MouseEvent e ) {
+			setThumbPressed( false );
+			super.mouseReleased( e );
+		}
+
+		@Override
+		public void mouseDragged( MouseEvent e ) {
+			super.mouseDragged( e );
+
+			if( isDragging() &&
+				slider.getSnapToTicks() &&
+				slider.isEnabled() &&
+				!UIManager.getBoolean( "Slider.snapToTicksOnReleased" ) )
+			{
+				calculateThumbLocation();
+				slider.repaint();
+			}
+		}
+
+		protected void setThumbHover( boolean hover ) {
+			if( hover != thumbHover ) {
+				thumbHover = hover;
+				slider.repaint( thumbRect );
+			}
+		}
+
+		protected void setThumbPressed( boolean pressed ) {
+			if( pressed != thumbPressed ) {
+				thumbPressed = pressed;
+				slider.repaint( thumbRect );
+			}
+		}
+
+		protected boolean isOverThumb( MouseEvent e ) {
+			return e != null && slider.isEnabled() && thumbRect.contains( e.getX(), e.getY() );
+		}
+	}
 }

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

@@ -21,6 +21,7 @@ import java.awt.Color;
 import java.awt.Component;
 import java.awt.Container;
 import java.awt.Dimension;
+import java.awt.FontMetrics;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.Insets;
@@ -39,7 +40,9 @@ import javax.swing.LookAndFeel;
 import javax.swing.SwingConstants;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.UIResource;
 import javax.swing.plaf.basic.BasicSpinnerUI;
+import com.formdev.flatlaf.FlatClientProperties;
 
 /**
  * Provides the Flat LaF UI delegate for {@link javax.swing.JSpinner}.
@@ -56,19 +59,20 @@ import javax.swing.plaf.basic.BasicSpinnerUI;
  *
  * <!-- FlatSpinnerUI -->
  *
- * @uiDefault Component.focusWidth				int
- * @uiDefault Component.arc						int
  * @uiDefault Component.minimumWidth			int
- * @uiDefault Component.arrowType				String	triangle (default) or chevron
+ * @uiDefault Spinner.buttonStyle				String	button (default) or none
+ * @uiDefault Component.arrowType				String	chevron (default) or triangle
  * @uiDefault Component.isIntelliJTheme			boolean
  * @uiDefault Component.borderColor				Color
  * @uiDefault Component.disabledBorderColor		Color
  * @uiDefault Spinner.disabledBackground		Color
  * @uiDefault Spinner.disabledForeground		Color
+ * @uiDefault Spinner.focusedBackground			Color	optional
  * @uiDefault Spinner.buttonBackground			Color
  * @uiDefault Spinner.buttonArrowColor			Color
  * @uiDefault Spinner.buttonDisabledArrowColor	Color
  * @uiDefault Spinner.buttonHoverArrowColor		Color
+ * @uiDefault Spinner.buttonPressedArrowColor	Color
  * @uiDefault Spinner.padding					Insets
  *
  * @author Karl Tauber
@@ -78,19 +82,20 @@ public class FlatSpinnerUI
 {
 	private Handler handler;
 
-	protected int focusWidth;
-	protected int arc;
 	protected int minimumWidth;
+	protected String buttonStyle;
 	protected String arrowType;
 	protected boolean isIntelliJTheme;
 	protected Color borderColor;
 	protected Color disabledBorderColor;
 	protected Color disabledBackground;
 	protected Color disabledForeground;
+	protected Color focusedBackground;
 	protected Color buttonBackground;
 	protected Color buttonArrowColor;
 	protected Color buttonDisabledArrowColor;
 	protected Color buttonHoverArrowColor;
+	protected Color buttonPressedArrowColor;
 	protected Insets padding;
 
 	public static ComponentUI createUI( JComponent c ) {
@@ -103,25 +108,23 @@ public class FlatSpinnerUI
 
 		LookAndFeel.installProperty( spinner, "opaque", false );
 
-		focusWidth = UIManager.getInt( "Component.focusWidth" );
-		arc = UIManager.getInt( "Component.arc" );
 		minimumWidth = UIManager.getInt( "Component.minimumWidth" );
+		buttonStyle = UIManager.getString( "Spinner.buttonStyle" );
 		arrowType = UIManager.getString( "Component.arrowType" );
 		isIntelliJTheme = UIManager.getBoolean( "Component.isIntelliJTheme" );
 		borderColor = UIManager.getColor( "Component.borderColor" );
 		disabledBorderColor = UIManager.getColor( "Component.disabledBorderColor" );
 		disabledBackground = UIManager.getColor( "Spinner.disabledBackground" );
 		disabledForeground = UIManager.getColor( "Spinner.disabledForeground" );
+		focusedBackground = UIManager.getColor( "Spinner.focusedBackground" );
 		buttonBackground = UIManager.getColor( "Spinner.buttonBackground" );
 		buttonArrowColor = UIManager.getColor( "Spinner.buttonArrowColor" );
 		buttonDisabledArrowColor = UIManager.getColor( "Spinner.buttonDisabledArrowColor" );
 		buttonHoverArrowColor = UIManager.getColor( "Spinner.buttonHoverArrowColor" );
+		buttonPressedArrowColor = UIManager.getColor( "Spinner.buttonPressedArrowColor" );
 		padding = UIManager.getInsets( "Spinner.padding" );
 
-		// scale
-		padding = scale( padding );
-
-		MigLayoutVisualPadding.install( spinner, focusWidth );
+		MigLayoutVisualPadding.install( spinner );
 	}
 
 	@Override
@@ -132,10 +135,12 @@ public class FlatSpinnerUI
 		disabledBorderColor = null;
 		disabledBackground = null;
 		disabledForeground = null;
+		focusedBackground = null;
 		buttonBackground = null;
 		buttonArrowColor = null;
 		buttonDisabledArrowColor = null;
 		buttonHoverArrowColor = null;
+		buttonPressedArrowColor = null;
 		padding = null;
 
 		MigLayoutVisualPadding.uninstall( spinner );
@@ -146,6 +151,7 @@ public class FlatSpinnerUI
 		super.installListeners();
 
 		addEditorFocusListener( spinner.getEditor() );
+		spinner.addFocusListener( getHandler() );
 		spinner.addPropertyChangeListener( getHandler() );
 	}
 
@@ -154,6 +160,7 @@ public class FlatSpinnerUI
 		super.uninstallListeners();
 
 		removeEditorFocusListener( spinner.getEditor() );
+		spinner.removeFocusListener( getHandler() );
 		spinner.removePropertyChangeListener( getHandler() );
 
 		handler = null;
@@ -168,14 +175,7 @@ public class FlatSpinnerUI
 	@Override
 	protected JComponent createEditor() {
 		JComponent editor = super.createEditor();
-
-		// explicitly make non-opaque
-		editor.setOpaque( false );
-		JTextField textField = getEditorTextField( editor );
-		if( textField != null )
-			textField.setOpaque( false );
-
-		updateEditorColors();
+		configureEditor( editor );
 		return editor;
 	}
 
@@ -183,8 +183,21 @@ public class FlatSpinnerUI
 	protected void replaceEditor( JComponent oldEditor, JComponent newEditor ) {
 		super.replaceEditor( oldEditor, newEditor );
 
+		configureEditor( newEditor );
+
 		removeEditorFocusListener( oldEditor );
 		addEditorFocusListener( newEditor );
+	}
+
+	/** @since 1.6 */
+	protected void configureEditor( JComponent editor ) {
+		// explicitly make non-opaque
+		editor.setOpaque( false );
+		JTextField textField = getEditorTextField( editor );
+		if( textField != null )
+			textField.setOpaque( false );
+
+		updateEditorPadding();
 		updateEditorColors();
 	}
 
@@ -200,23 +213,63 @@ public class FlatSpinnerUI
 			textField.removeFocusListener( getHandler() );
 	}
 
+	private void updateEditorPadding() {
+		JTextField textField = getEditorTextField( spinner.getEditor() );
+		if( textField != null )
+			textField.putClientProperty( FlatClientProperties.TEXT_FIELD_PADDING, padding );
+	}
+
 	private void updateEditorColors() {
 		JTextField textField = getEditorTextField( spinner.getEditor() );
 		if( textField != null ) {
 			// use non-UIResource colors because when SwingUtilities.updateComponentTreeUI()
 			// is used, then the text field is updated after the spinner and the
 			// colors are again replaced with default colors
-			textField.setForeground( FlatUIUtils.nonUIResource( spinner.getForeground() ) );
-			textField.setDisabledTextColor( FlatUIUtils.nonUIResource( disabledForeground ) );
+			textField.setForeground( FlatUIUtils.nonUIResource( getForeground( true ) ) );
+			textField.setDisabledTextColor( FlatUIUtils.nonUIResource( getForeground( false ) ) );
 		}
 	}
 
-	private JTextField getEditorTextField( JComponent editor ) {
+	private static JTextField getEditorTextField( JComponent editor ) {
 		return editor instanceof JSpinner.DefaultEditor
 			? ((JSpinner.DefaultEditor)editor).getTextField()
 			: null;
 	}
 
+	/**
+	 * @since 1.3
+	 */
+	public static boolean isPermanentFocusOwner( JSpinner spinner ) {
+		if( FlatUIUtils.isPermanentFocusOwner( spinner ) )
+			return true;
+
+		JTextField textField = getEditorTextField( spinner.getEditor() );
+		return (textField != null)
+			? FlatUIUtils.isPermanentFocusOwner( textField )
+			: false;
+	}
+
+	protected Color getBackground( boolean enabled ) {
+		if( enabled ) {
+			Color background = spinner.getBackground();
+
+			// always use explicitly set color
+			if( !(background instanceof UIResource) )
+				return background;
+
+			// focused
+			if( focusedBackground != null && isPermanentFocusOwner( spinner ) )
+				return focusedBackground;
+
+			return background;
+		} else
+			return isIntelliJTheme ? FlatUIUtils.getParentBackground( spinner ) : disabledBackground;
+	}
+
+	protected Color getForeground( boolean enabled ) {
+		return enabled ? spinner.getForeground() : disabledForeground;
+	}
+
 	@Override
 	protected LayoutManager createLayout() {
 		return getHandler();
@@ -234,9 +287,9 @@ public class FlatSpinnerUI
 
 	private Component createArrowButton( int direction, String name ) {
 		FlatArrowButton button = new FlatArrowButton( direction, arrowType, buttonArrowColor,
-			buttonDisabledArrowColor, buttonHoverArrowColor, null );
+			buttonDisabledArrowColor, buttonHoverArrowColor, null, buttonPressedArrowColor, null );
 		button.setName( name );
-		button.setYOffset( (direction == SwingConstants.NORTH) ? 1 : -1 );
+		button.setYOffset( (direction == SwingConstants.NORTH) ? 1.25f : -1.25f );
 		if( direction == SwingConstants.NORTH )
 			installNextButtonListeners( button );
 		else
@@ -246,48 +299,55 @@ public class FlatSpinnerUI
 
 	@Override
 	public void update( Graphics g, JComponent c ) {
+		float focusWidth = FlatUIUtils.getBorderFocusWidth( c );
+		float arc = FlatUIUtils.getBorderArc( c );
+
 		// fill background if opaque to avoid garbage if user sets opaque to true
-		if( c.isOpaque() && (focusWidth > 0 || arc != 0) )
+		if( c.isOpaque() && (focusWidth > 0 || arc > 0) )
 			FlatUIUtils.paintParentBackground( g, c );
 
 		Graphics2D g2 = (Graphics2D) g;
-		FlatUIUtils.setRenderingHints( g2 );
+		Object[] oldRenderingHints = FlatUIUtils.setRenderingHints( g2 );
 
 		int width = c.getWidth();
 		int height = c.getHeight();
-		float focusWidth = (c.getBorder() instanceof FlatBorder) ? scale( (float) this.focusWidth ) : 0;
-		float arc = (c.getBorder() instanceof FlatRoundBorder) ? scale( (float) this.arc ) : 0;
-		Component nextButton = getHandler().nextButton;
-		int arrowX = nextButton.getX();
-		int arrowWidth = nextButton.getWidth();
 		boolean enabled = spinner.isEnabled();
-		boolean isLeftToRight = spinner.getComponentOrientation().isLeftToRight();
 
 		// paint background
-		g2.setColor( enabled
-			? c.getBackground()
-			: (isIntelliJTheme ? FlatUIUtils.getParentBackground( c ) : disabledBackground) );
+		g2.setColor( getBackground( enabled ) );
 		FlatUIUtils.paintComponentBackground( g2, 0, 0, width, height, focusWidth, arc );
 
-		// paint arrow buttons background
-		if( enabled ) {
-			g2.setColor( buttonBackground );
-			Shape oldClip = g2.getClip();
-			if( isLeftToRight )
-				g2.clipRect( arrowX, 0, width - arrowX, height );
-			else
-				g2.clipRect( 0, 0, arrowX + arrowWidth, height );
-			FlatUIUtils.paintComponentBackground( g2, 0, 0, width, height, focusWidth, arc );
-			g2.setClip( oldClip );
+		// paint button background and separator
+		boolean paintButton = !"none".equals( buttonStyle );
+		Handler handler = getHandler();
+		if( paintButton && (handler.nextButton != null || handler.previousButton != null) ) {
+			Component button = (handler.nextButton != null) ? handler.nextButton : handler.previousButton;
+			int arrowX = button.getX();
+			int arrowWidth = button.getWidth();
+			boolean isLeftToRight = spinner.getComponentOrientation().isLeftToRight();
+
+			// paint arrow buttons background
+			if( enabled ) {
+				g2.setColor( buttonBackground );
+				Shape oldClip = g2.getClip();
+				if( isLeftToRight )
+					g2.clipRect( arrowX, 0, width - arrowX, height );
+				else
+					g2.clipRect( 0, 0, arrowX + arrowWidth, height );
+				FlatUIUtils.paintComponentBackground( g2, 0, 0, width, height, focusWidth, arc );
+				g2.setClip( oldClip );
+			}
+
+			// paint vertical line between value and arrow buttons
+			g2.setColor( enabled ? borderColor : disabledBorderColor );
+			float lw = scale( 1f );
+			float lx = isLeftToRight ? arrowX : arrowX + arrowWidth - lw;
+			g2.fill( new Rectangle2D.Float( lx, focusWidth, lw, height - 1 - (focusWidth * 2) ) );
 		}
 
-		// paint vertical line between value and arrow buttons
-		g2.setColor( enabled ? borderColor : disabledBorderColor );
-		float lw = scale( 1f );
-		float lx = isLeftToRight ? arrowX : arrowX + arrowWidth - lw;
-		g2.fill( new Rectangle2D.Float( lx, focusWidth, lw, height - 1 - (focusWidth * 2) ) );
-
 		paint( g, c );
+
+		FlatUIUtils.resetRenderingHints( g, oldRenderingHints );
 	}
 
 	//---- class Handler ------------------------------------------------------
@@ -323,13 +383,15 @@ public class FlatSpinnerUI
 		@Override
 		public Dimension preferredLayoutSize( Container parent ) {
 			Insets insets = parent.getInsets();
+			Insets padding = scale( FlatSpinnerUI.this.padding );
 			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;
+			float focusWidth = FlatUIUtils.getBorderFocusWidth( spinner );
 			return new Dimension(
-				Math.max( insets.left + insets.right + editorSize.width + padding.left + padding.right + innerHeight, scale( minimumWidth + (focusWidth * 2) ) ),
+				Math.max( insets.left + insets.right + editorSize.width + padding.left + padding.right + innerHeight, scale( minimumWidth ) + Math.round( focusWidth * 2 ) ),
 				insets.top + insets.bottom + innerHeight );
 		}
 
@@ -353,8 +415,12 @@ public class FlatSpinnerUI
 			Rectangle editorRect = new Rectangle( r );
 			Rectangle buttonsRect = new Rectangle( r );
 
-			// make button area square
-			int buttonsWidth = r.height;
+			// limit buttons width to height of a raw spinner (without insets)
+			FontMetrics fm = spinner.getFontMetrics( spinner.getFont() );
+			int maxButtonWidth = fm.getHeight() + scale( padding.top ) + scale( padding.bottom );
+
+			// make button area square (if spinner has preferred height)
+			int buttonsWidth = Math.min( parent.getPreferredSize().height - insets.top - insets.bottom, maxButtonWidth );
 			buttonsRect.width = buttonsWidth;
 
 			if( parent.getComponentOrientation().isLeftToRight() ) {
@@ -366,14 +432,16 @@ public class FlatSpinnerUI
 			}
 
 			if( editor != null )
-				editor.setBounds( FlatUIUtils.subtractInsets( editorRect, padding ) );
+				editor.setBounds( editorRect );
 
-			int nextHeight = Math.round( buttonsRect.height / 2f );
+			int nextHeight = (buttonsRect.height / 2) + (buttonsRect.height % 2); // round up
 			if( nextButton != null )
 				nextButton.setBounds( buttonsRect.x, buttonsRect.y, buttonsRect.width, nextHeight );
 			if( previousButton != null ) {
-				previousButton.setBounds( buttonsRect.x, buttonsRect.y + nextHeight,
-					buttonsRect.width, buttonsRect.height - nextHeight );
+				// for precise layout of arrows, the "previous" button has the same height
+				// as the "next" button and may overlap on uneven buttonsRect.height
+				int previousY = buttonsRect.y + buttonsRect.height - nextHeight;
+				previousButton.setBounds( buttonsRect.x, previousY, buttonsRect.width, nextHeight );
 			}
 		}
 
@@ -381,11 +449,20 @@ public class FlatSpinnerUI
 
 		@Override
 		public void focusGained( FocusEvent e ) {
+			// necessary to update focus border
 			spinner.repaint();
+
+			// if spinner gained focus, transfer it to the editor text field
+			if( e.getComponent() == spinner ) {
+				JTextField textField = getEditorTextField( spinner.getEditor() );
+				if( textField != null )
+					textField.requestFocusInWindow();
+			}
 		}
 
 		@Override
 		public void focusLost( FocusEvent e ) {
+			// necessary to update focus border
 			spinner.repaint();
 		}
 
@@ -398,6 +475,14 @@ public class FlatSpinnerUI
 				case "enabled":
 					updateEditorColors();
 					break;
+
+				case FlatClientProperties.COMPONENT_ROUND_RECT:
+					spinner.repaint();
+					break;
+
+				case FlatClientProperties.MINIMUM_WIDTH:
+					spinner.revalidate();
+					break;
 			}
 		}
 	}

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

@@ -17,11 +17,17 @@
 package com.formdev.flatlaf.ui;
 
 import java.awt.Color;
+import java.awt.Container;
 import java.awt.Cursor;
+import java.awt.Graphics;
+import java.awt.Insets;
+import java.awt.event.MouseEvent;
+import java.beans.PropertyChangeEvent;
 import javax.swing.JButton;
 import javax.swing.JComponent;
 import javax.swing.JSplitPane;
 import javax.swing.SwingConstants;
+import javax.swing.ToolTipManager;
 import javax.swing.UIManager;
 import javax.swing.plaf.ComponentUI;
 import javax.swing.plaf.basic.BasicSplitPaneDivider;
@@ -40,12 +46,21 @@ import com.formdev.flatlaf.util.UIScale;
  * @uiDefault SplitPaneDivider.border					Border
  * @uiDefault SplitPaneDivider.draggingColor			Color	only used if continuousLayout is false
  *
+ * <!-- JSplitPane -->
+ *
+ * @uiDefault SplitPane.continuousLayout				boolean
+ *
  * <!-- FlatSplitPaneUI -->
  *
- * @uiDefault Component.arrowType						String	triangle (default) or chevron
- * @uiDefault SplitPane.continuousLayout				boolean
+ * @uiDefault Component.arrowType						String	chevron (default) or triangle
  * @uiDefault SplitPaneDivider.oneTouchArrowColor		Color
  * @uiDefault SplitPaneDivider.oneTouchHoverArrowColor	Color
+ * @uiDefault SplitPaneDivider.oneTouchPressedArrowColor Color
+ * @uiDefault SplitPaneDivider.style					String	grip (default) or plain
+ * @uiDefault SplitPaneDivider.gripColor				Color
+ * @uiDefault SplitPaneDivider.gripDotCount				int
+ * @uiDefault SplitPaneDivider.gripDotSize				int
+ * @uiDefault SplitPaneDivider.gripGap					int
  *
  * @author Karl Tauber
  */
@@ -53,9 +68,9 @@ public class FlatSplitPaneUI
 	extends BasicSplitPaneUI
 {
 	protected String arrowType;
-	private Boolean continuousLayout;
-	private Color oneTouchArrowColor;
-	private Color oneTouchHoverArrowColor;
+	protected Color oneTouchArrowColor;
+	protected Color oneTouchHoverArrowColor;
+	protected Color oneTouchPressedArrowColor;
 
 	public static ComponentUI createUI( JComponent c ) {
 		return new FlatSplitPaneUI();
@@ -69,15 +84,18 @@ public class FlatSplitPaneUI
 		// used in there on LaF switching
 		oneTouchArrowColor = UIManager.getColor( "SplitPaneDivider.oneTouchArrowColor" );
 		oneTouchHoverArrowColor = UIManager.getColor( "SplitPaneDivider.oneTouchHoverArrowColor" );
+		oneTouchPressedArrowColor = UIManager.getColor( "SplitPaneDivider.oneTouchPressedArrowColor" );
 
 		super.installDefaults();
-
-		continuousLayout = (Boolean) UIManager.get( "SplitPane.continuousLayout" );
 	}
 
 	@Override
-	public boolean isContinuousLayout() {
-		return super.isContinuousLayout() || (continuousLayout != null && Boolean.TRUE.equals( continuousLayout ));
+	protected void uninstallDefaults() {
+		super.uninstallDefaults();
+
+		oneTouchArrowColor = null;
+		oneTouchHoverArrowColor = null;
+		oneTouchPressedArrowColor = null;
 	}
 
 	@Override
@@ -87,11 +105,19 @@ public class FlatSplitPaneUI
 
 	//---- class FlatSplitPaneDivider -----------------------------------------
 
-	private class FlatSplitPaneDivider
+	protected class FlatSplitPaneDivider
 		extends BasicSplitPaneDivider
 	{
-		public FlatSplitPaneDivider( BasicSplitPaneUI ui ) {
+		protected final String style = UIManager.getString( "SplitPaneDivider.style" );
+		protected final Color gripColor = UIManager.getColor( "SplitPaneDivider.gripColor" );
+		protected final int gripDotCount = FlatUIUtils.getUIInt( "SplitPaneDivider.gripDotCount", 3 );
+		protected final int gripDotSize = FlatUIUtils.getUIInt( "SplitPaneDivider.gripDotSize", 3 );
+		protected final int gripGap = FlatUIUtils.getUIInt( "SplitPaneDivider.gripGap", 2 );
+
+		protected FlatSplitPaneDivider( BasicSplitPaneUI ui ) {
 			super( ui );
+
+			setLayout( new FlatDividerLayout() );
 		}
 
 		@Override
@@ -109,16 +135,67 @@ public class FlatSplitPaneUI
 			return new FlatOneTouchButton( false );
 		}
 
+		@Override
+		public void propertyChange( PropertyChangeEvent e ) {
+			super.propertyChange( e );
+
+			switch( e.getPropertyName() ) {
+				case JSplitPane.DIVIDER_LOCATION_PROPERTY:
+					// necessary to show/hide one-touch buttons on expand/collapse
+					revalidate();
+					break;
+			}
+		}
+
+		@Override
+		public void paint( Graphics g ) {
+			super.paint( g );
+
+			if( "plain".equals( style ) )
+				return;
+
+			Object[] oldRenderingHints = FlatUIUtils.setRenderingHints( g );
+
+			g.setColor( gripColor );
+			paintGrip( g, 0, 0, getWidth(), getHeight() );
+
+			FlatUIUtils.resetRenderingHints( g, oldRenderingHints );
+		}
+
+		protected void paintGrip( Graphics g, int x, int y, int width, int height ) {
+			FlatUIUtils.paintGrip( g, x, y, width, height,
+				splitPane.getOrientation() == JSplitPane.VERTICAL_SPLIT,
+				gripDotCount, gripDotSize, gripGap, true );
+		}
+
+		protected boolean isLeftCollapsed() {
+			int location = splitPane.getDividerLocation();
+			Insets insets = splitPane.getInsets();
+			return (orientation == JSplitPane.VERTICAL_SPLIT)
+				? location == insets.top
+				: location == insets.left;
+		}
+
+		protected boolean isRightCollapsed() {
+			int location = splitPane.getDividerLocation();
+			Insets insets = splitPane.getInsets();
+			return (orientation == JSplitPane.VERTICAL_SPLIT)
+				? location == (splitPane.getHeight() - getHeight() - insets.bottom)
+				: location == (splitPane.getWidth() - getWidth() - insets.right);
+		}
+
 		//---- class FlatOneTouchButton ---------------------------------------
 
-		private class FlatOneTouchButton
+		protected class FlatOneTouchButton
 			extends FlatArrowButton
 		{
-			private final boolean left;
+			protected final boolean left;
 
-			public FlatOneTouchButton( boolean left ) {
-				super( SwingConstants.NORTH, arrowType, oneTouchArrowColor, null, oneTouchHoverArrowColor, null );
+			protected FlatOneTouchButton( boolean left ) {
+				super( SwingConstants.NORTH, arrowType, oneTouchArrowColor, null,
+					oneTouchHoverArrowColor, null, oneTouchPressedArrowColor, null );
 				setCursor( Cursor.getPredefinedCursor( Cursor.DEFAULT_CURSOR ) );
+				ToolTipManager.sharedInstance().registerComponent( this );
 
 				this.left = left;
 			}
@@ -129,7 +206,67 @@ public class FlatSplitPaneUI
 					? (left ? SwingConstants.NORTH : SwingConstants.SOUTH)
 					: (left ? SwingConstants.WEST : SwingConstants.EAST);
 			}
+
+			@Override
+			public String getToolTipText( MouseEvent e ) {
+				String key = (orientation == JSplitPane.VERTICAL_SPLIT)
+					? (left
+						? (isRightCollapsed()
+							? "SplitPaneDivider.expandBottomToolTipText"
+							: "SplitPaneDivider.collapseTopToolTipText")
+						: (isLeftCollapsed()
+							? "SplitPaneDivider.expandTopToolTipText"
+							: "SplitPaneDivider.collapseBottomToolTipText"))
+					: (left
+						? (isRightCollapsed()
+							? "SplitPaneDivider.expandRightToolTipText"
+							: "SplitPaneDivider.collapseLeftToolTipText")
+						: (isLeftCollapsed()
+							? "SplitPaneDivider.expandLeftToolTipText"
+							: "SplitPaneDivider.collapseRightToolTipText"));
+
+				// get text from client property
+				Object value = splitPane.getClientProperty( key );
+				if( value instanceof String )
+					return (String) value;
+
+				// get text from bundle
+				return UIManager.getString( key, getLocale() );
+			}
+		}
+
+		//---- class FlatDividerLayout ----------------------------------------
+
+		protected class FlatDividerLayout
+			extends DividerLayout
+		{
+			@Override
+			public void layoutContainer( Container c ) {
+				super.layoutContainer( c );
+
+				if( leftButton == null || rightButton == null || !splitPane.isOneTouchExpandable() )
+					return;
+
+				// increase side of buttons, which makes them easier to hit by the user
+				// and avoids cut arrows at small divider sizes
+				int extraSize = UIScale.scale( 4 );
+				if( orientation == JSplitPane.VERTICAL_SPLIT ) {
+					leftButton.setSize( leftButton.getWidth() + extraSize, leftButton.getHeight() );
+					rightButton.setBounds( leftButton.getX() + leftButton.getWidth(), rightButton.getY(),
+						rightButton.getWidth() + extraSize, rightButton.getHeight() );
+				} else {
+					leftButton.setSize( leftButton.getWidth(), leftButton.getHeight() + extraSize );
+					rightButton.setBounds( rightButton.getX(), leftButton.getY() + leftButton.getHeight(),
+						rightButton.getWidth(), rightButton.getHeight() + extraSize );
+				}
+
+				// hide buttons if not applicable
+				boolean leftCollapsed = isLeftCollapsed();
+				if( leftCollapsed )
+					rightButton.setLocation( leftButton.getLocation() );
+				leftButton.setVisible( !leftCollapsed );
+				rightButton.setVisible( !isRightCollapsed() );
+			}
 		}
 	}
-
 }

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

@@ -86,7 +86,7 @@ public class FlatTableCellBorder
 		/**
 		 * Checks whether at least one selected cell is editable.
 		 */
-		private boolean isSelectionEditable( JTable table ) {
+		protected boolean isSelectionEditable( JTable table ) {
 			if( table.getRowSelectionAllowed() ) {
 				int columnCount = table.getColumnCount();
 				int[] selectedRows = table.getSelectedRows();

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

@@ -0,0 +1,137 @@
+/*
+ * Copyright 2021 FormDev Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.formdev.flatlaf.ui;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.geom.Rectangle2D;
+import javax.swing.JScrollBar;
+import javax.swing.JScrollPane;
+import javax.swing.JViewport;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.table.JTableHeader;
+import javax.swing.table.TableColumn;
+import com.formdev.flatlaf.util.UIScale;
+
+/**
+ * Cell border for {@code sun.swing.table.DefaultTableCellHeaderRenderer}
+ * (used by {@link javax.swing.table.JTableHeader}).
+ * <p>
+ * Uses separate cell margins from UI defaults to allow easy customizing.
+ *
+ * @author Karl Tauber
+ * @since 1.2
+ */
+public class FlatTableHeaderBorder
+	extends FlatEmptyBorder
+{
+	protected Color separatorColor = UIManager.getColor( "TableHeader.separatorColor" );
+	protected Color bottomSeparatorColor = UIManager.getColor( "TableHeader.bottomSeparatorColor" );
+	/** @since 1.6 */ protected boolean showTrailingVerticalLine = UIManager.getBoolean( "TableHeader.showTrailingVerticalLine" );
+
+	public FlatTableHeaderBorder() {
+		super( UIManager.getInsets( "TableHeader.cellMargins" ) );
+	}
+
+	@Override
+	public void paintBorder( Component c, Graphics g, int x, int y, int width, int height ) {
+		JTableHeader header = (JTableHeader) SwingUtilities.getAncestorOfClass( JTableHeader.class, c );
+		boolean leftToRight = (header != null ? header : c).getComponentOrientation().isLeftToRight();
+		boolean paintLeft = !leftToRight;
+		boolean paintRight = leftToRight;
+
+		if( header != null ) {
+			int hx = SwingUtilities.convertPoint( c, x, y, header ).x;
+			if( isDraggedColumn( header, hx ) )
+				paintLeft = paintRight = true;
+			else {
+				if( hx <= 0 && !leftToRight && hideTrailingVerticalLine( header ) )
+					paintLeft = false;
+				if( hx + width >= header.getWidth() && leftToRight && hideTrailingVerticalLine( header ) )
+					paintRight = false;
+			}
+		}
+
+		float lineWidth = UIScale.scale( 1f );
+
+		Graphics2D g2 = (Graphics2D) g.create();
+		try {
+			FlatUIUtils.setRenderingHints( g2 );
+
+			// paint column separator lines
+			g2.setColor( separatorColor );
+			if( paintLeft )
+				g2.fill( new Rectangle2D.Float( x, y, lineWidth, height - lineWidth ) );
+			if( paintRight )
+				g2.fill( new Rectangle2D.Float( x + width - lineWidth, y, lineWidth, height - lineWidth ) );
+
+			// paint bottom line
+			g2.setColor( bottomSeparatorColor );
+			g2.fill( new Rectangle2D.Float( x, y + height - lineWidth, width, lineWidth ) );
+		} finally {
+			g2.dispose();
+		}
+	}
+
+	protected boolean isDraggedColumn( JTableHeader header, int x ) {
+		TableColumn draggedColumn = header.getDraggedColumn();
+		if( draggedColumn == null )
+			return false;
+
+		int draggedDistance = header.getDraggedDistance();
+		if( draggedDistance == 0 )
+			return false;
+
+		int columnCount = header.getColumnModel().getColumnCount();
+		for( int i = 0; i < columnCount; i++ ) {
+			if( header.getHeaderRect( i ).x + draggedDistance == x )
+				return true;
+		}
+
+		return false;
+	}
+
+	protected boolean hideTrailingVerticalLine( JTableHeader header ) {
+		if( showTrailingVerticalLine )
+			return false;
+
+		// do not hide if table header is not a child of a scroll pane
+		Container viewport = header.getParent();
+		Container viewportParent = (viewport != null) ? viewport.getParent() : null;
+		if( !(viewportParent instanceof JScrollPane) )
+			return false;
+
+		// do not hide if table header is not the column header of the scroll pane
+		JScrollPane scrollPane = (JScrollPane) viewportParent;
+		JViewport columnHeader = scrollPane.getColumnHeader();
+		if( viewport != columnHeader )
+			return false;
+
+		// hide if vertical scroll bar is not shown
+		JScrollBar vsb = scrollPane.getVerticalScrollBar();
+		if( vsb == null || !vsb.isVisible() )
+			return true;
+
+		// if "ScrollPane.fillUpperCorner" is true, then javax.swing.ScrollPaneLayout
+		// extends the vertical scrollbar into the upper right/left corner
+		return vsb.getY() == viewport.getY();
+	}
+}