mirror of
https://github.com/JFormDesigner/FlatLaf.git
synced 2026-02-13 15:27:16 -06:00
Window decorations: support fullWindowContent mode on Windows and Linux
This commit is contained in:
@@ -266,7 +266,9 @@ public interface FlatClientProperties
|
||||
* <strong>Value type</strong> {@link java.lang.Boolean}
|
||||
*
|
||||
* @since 2.5
|
||||
* @deprecated No longer used since FlatLaf 3.4. Retained for API compatibility.
|
||||
*/
|
||||
@Deprecated
|
||||
String COMPONENT_TITLE_BAR_CAPTION = "JComponent.titleBarCaption";
|
||||
|
||||
|
||||
@@ -274,7 +276,7 @@ public interface FlatClientProperties
|
||||
|
||||
/**
|
||||
* Marks the panel as placeholder for the iconfify/maximize/close buttons
|
||||
* in fullWindowContent mode.
|
||||
* in fullWindowContent mode. See {@link #FULL_WINDOW_CONTENT}.
|
||||
* <p>
|
||||
* If fullWindowContent mode is enabled, the preferred size of the panel is equal
|
||||
* to the size of the iconfify/maximize/close buttons. Otherwise is is {@code 0,0}.
|
||||
@@ -462,6 +464,32 @@ public interface FlatClientProperties
|
||||
*/
|
||||
String MENU_BAR_EMBEDDED = "JRootPane.menuBarEmbedded";
|
||||
|
||||
/**
|
||||
* Specifies whether the content pane (and the glass pane) should be extended
|
||||
* into the window title bar area
|
||||
* (requires enabled window decorations). Default is {@code false}.
|
||||
* <p>
|
||||
* On macOS, use client property {@code apple.awt.fullWindowContent}
|
||||
* (see <a href="https://www.formdev.com/flatlaf/macos/#full_window_content">macOS Full window content</a>).
|
||||
* <p>
|
||||
* Setting this enables/disables full window content
|
||||
* for the {@code JFrame} or {@code JDialog} that contains the root pane.
|
||||
* <p>
|
||||
* If {@code true}, the content pane (and the glass pane) is extended into
|
||||
* the title bar area. The window icon and title are hidden.
|
||||
* Only the iconfify/maximize/close buttons stay visible in the upper right corner
|
||||
* (and overlap the content pane).
|
||||
* <p>
|
||||
* The user can left-click-and-drag on the title bar area to move the window,
|
||||
* except when clicking on a component that processes mouse events (e.g. buttons or menus).
|
||||
* <p>
|
||||
* <strong>Component</strong> {@link javax.swing.JRootPane}<br>
|
||||
* <strong>Value type</strong> {@link java.lang.Boolean}
|
||||
*
|
||||
* @since 3.4
|
||||
*/
|
||||
String FULL_WINDOW_CONTENT = "FlatLaf.fullWindowContent";
|
||||
|
||||
/**
|
||||
* Contains the current bounds of the iconfify/maximize/close buttons
|
||||
* (in root pane coordinates) if fullWindowContent mode is enabled.
|
||||
|
||||
@@ -21,11 +21,12 @@ import java.awt.Component;
|
||||
import java.awt.Container;
|
||||
import java.awt.Graphics;
|
||||
import java.awt.Graphics2D;
|
||||
import java.awt.Point;
|
||||
import java.awt.Rectangle;
|
||||
import java.awt.Toolkit;
|
||||
import java.awt.Window;
|
||||
import java.beans.PropertyChangeListener;
|
||||
import java.util.List;
|
||||
import java.util.function.Predicate;
|
||||
import javax.swing.JDialog;
|
||||
import javax.swing.JFrame;
|
||||
import javax.swing.JRootPane;
|
||||
@@ -218,13 +219,13 @@ public class FlatNativeWindowBorder
|
||||
}
|
||||
|
||||
static void setTitleBarHeightAndHitTestSpots( Window window, int titleBarHeight,
|
||||
List<Rectangle> hitTestSpots, Rectangle appIconBounds, Rectangle minimizeButtonBounds,
|
||||
Predicate<Point> hitTestCallback, Rectangle appIconBounds, Rectangle minimizeButtonBounds,
|
||||
Rectangle maximizeButtonBounds, Rectangle closeButtonBounds )
|
||||
{
|
||||
if( !isSupported() )
|
||||
return;
|
||||
|
||||
nativeProvider.updateTitleBarInfo( window, titleBarHeight, hitTestSpots,
|
||||
nativeProvider.updateTitleBarInfo( window, titleBarHeight, hitTestCallback,
|
||||
appIconBounds, minimizeButtonBounds, maximizeButtonBounds, closeButtonBounds );
|
||||
}
|
||||
|
||||
@@ -270,7 +271,7 @@ public class FlatNativeWindowBorder
|
||||
{
|
||||
boolean hasCustomDecoration( Window window );
|
||||
void setHasCustomDecoration( Window window, boolean hasCustomDecoration );
|
||||
void updateTitleBarInfo( Window window, int titleBarHeight, List<Rectangle> hitTestSpots,
|
||||
void updateTitleBarInfo( Window window, int titleBarHeight, Predicate<Point> hitTestCallback,
|
||||
Rectangle appIconBounds, Rectangle minimizeButtonBounds, Rectangle maximizeButtonBounds,
|
||||
Rectangle closeButtonBounds );
|
||||
|
||||
|
||||
@@ -269,15 +269,28 @@ public class FlatRootPaneUI
|
||||
|
||||
// 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;
|
||||
private final static Integer TITLE_PANE_MOUSE_LAYER = JLayeredPane.FRAME_CONTENT_LAYER - 2;
|
||||
|
||||
// for fullWindowContent mode, layer title pane over frame content layer to allow placing title bar buttons over content
|
||||
/** @since 3.4 */
|
||||
protected final static Integer TITLE_PANE_FULL_WINDOW_CONTENT_LAYER = JLayeredPane.FRAME_CONTENT_LAYER + 1;
|
||||
|
||||
private Integer getLayerForTitlePane() {
|
||||
return isFullWindowContent( rootPane ) ? TITLE_PANE_FULL_WINDOW_CONTENT_LAYER : TITLE_PANE_LAYER;
|
||||
}
|
||||
|
||||
protected void setTitlePane( FlatTitlePane newTitlePane ) {
|
||||
JLayeredPane layeredPane = rootPane.getLayeredPane();
|
||||
|
||||
if( titlePane != null )
|
||||
if( titlePane != null ) {
|
||||
layeredPane.remove( titlePane );
|
||||
layeredPane.remove( titlePane.mouseLayer );
|
||||
}
|
||||
|
||||
if( newTitlePane != null )
|
||||
layeredPane.add( newTitlePane, TITLE_PANE_LAYER );
|
||||
if( newTitlePane != null ) {
|
||||
layeredPane.add( newTitlePane, getLayerForTitlePane() );
|
||||
layeredPane.add( newTitlePane.mouseLayer, TITLE_PANE_MOUSE_LAYER );
|
||||
}
|
||||
|
||||
titlePane = newTitlePane;
|
||||
}
|
||||
@@ -430,6 +443,17 @@ public class FlatRootPaneUI
|
||||
titlePane.titleBarColorsChanged();
|
||||
break;
|
||||
|
||||
case FlatClientProperties.FULL_WINDOW_CONTENT:
|
||||
if( titlePane != null ) {
|
||||
rootPane.getLayeredPane().setLayer( titlePane, getLayerForTitlePane() );
|
||||
titlePane.updateIcon();
|
||||
titlePane.updateVisibility();
|
||||
titlePane.updateFullWindowContentButtonsBoundsProperty();
|
||||
}
|
||||
FullWindowContentSupport.revalidatePlaceholders( rootPane );
|
||||
rootPane.revalidate();
|
||||
break;
|
||||
|
||||
case FlatClientProperties.FULL_WINDOW_CONTENT_BUTTONS_BOUNDS:
|
||||
FullWindowContentSupport.revalidatePlaceholders( rootPane );
|
||||
break;
|
||||
@@ -471,11 +495,14 @@ public class FlatRootPaneUI
|
||||
}
|
||||
}
|
||||
|
||||
/** @since 3.4 */
|
||||
protected static boolean isFullWindowContent( JRootPane rootPane ) {
|
||||
return FlatClientProperties.clientPropertyBoolean( rootPane, FlatClientProperties.FULL_WINDOW_CONTENT, false );
|
||||
}
|
||||
|
||||
protected static boolean isMenuBarEmbedded( JRootPane rootPane ) {
|
||||
RootPaneUI ui = rootPane.getUI();
|
||||
return ui instanceof FlatRootPaneUI &&
|
||||
((FlatRootPaneUI)ui).titlePane != null &&
|
||||
((FlatRootPaneUI)ui).titlePane.isMenuBarEmbedded();
|
||||
FlatTitlePane titlePane = getTitlePane( rootPane );
|
||||
return titlePane != null && titlePane.isMenuBarEmbedded();
|
||||
}
|
||||
|
||||
/** @since 2.4 */
|
||||
@@ -511,23 +538,21 @@ public class FlatRootPaneUI
|
||||
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();
|
||||
: rootPane.getSize(); // same as in JRootPane.RootLayout.preferredLayoutSize()
|
||||
|
||||
int width = contentSize.width; // title pane width is not considered here
|
||||
int height = titlePaneSize.height + contentSize.height;
|
||||
int height = contentSize.height;
|
||||
if( titlePane != null && !isFullWindowContent( rootPane ) )
|
||||
height += getSizeFunc.apply( titlePane ).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;
|
||||
if( menuBar != null && menuBar.isVisible() ) {
|
||||
Dimension menuBarSize = getSizeFunc.apply( menuBar );
|
||||
width = Math.max( width, menuBarSize.width );
|
||||
height += menuBarSize.height;
|
||||
}
|
||||
}
|
||||
|
||||
Insets insets = rootPane.getInsets();
|
||||
@@ -552,12 +577,23 @@ public class FlatRootPaneUI
|
||||
if( rootPane.getLayeredPane() != null )
|
||||
rootPane.getLayeredPane().setBounds( x, y, width, height );
|
||||
|
||||
// title pane
|
||||
// title pane (is a child of layered pane)
|
||||
int nextY = 0;
|
||||
if( titlePane != null ) {
|
||||
int prefHeight = !isFullScreen ? titlePane.getPreferredSize().height : 0;
|
||||
titlePane.setBounds( 0, 0, width, prefHeight );
|
||||
nextY += prefHeight;
|
||||
boolean isFullWindowContent = isFullWindowContent( rootPane );
|
||||
if( isFullWindowContent && !UIManager.getBoolean( FlatTitlePane.KEY_DEBUG_SHOW_RECTANGLES ) ) {
|
||||
// place title bar into top-right corner
|
||||
int tw = Math.min( titlePane.getPreferredSize().width, width );
|
||||
int tx = titlePane.getComponentOrientation().isLeftToRight() ? width - tw : 0;
|
||||
titlePane.setBounds( tx, 0, tw, prefHeight );
|
||||
} else
|
||||
titlePane.setBounds( 0, 0, width, prefHeight );
|
||||
|
||||
titlePane.mouseLayer.setBounds( 0, 0, width, prefHeight );
|
||||
|
||||
if( !isFullWindowContent )
|
||||
nextY += prefHeight;
|
||||
}
|
||||
|
||||
// glass pane
|
||||
@@ -568,7 +604,7 @@ public class FlatRootPaneUI
|
||||
rootPane.getGlassPane().setBounds( x, y + offset, width, height - offset );
|
||||
}
|
||||
|
||||
// menu bar
|
||||
// menu bar (is a child of layered pane)
|
||||
JMenuBar menuBar = rootPane.getJMenuBar();
|
||||
if( menuBar != null && menuBar.isVisible() ) {
|
||||
boolean embedded = !isFullScreen && titlePane != null && titlePane.isMenuBarEmbedded();
|
||||
@@ -576,13 +612,23 @@ public class FlatRootPaneUI
|
||||
titlePane.validate();
|
||||
menuBar.setBounds( titlePane.getMenuBarBounds() );
|
||||
} else {
|
||||
int mx = 0;
|
||||
int mw = width;
|
||||
if( titlePane != null && isFullWindowContent( rootPane ) ) {
|
||||
// make menu bar width smaller to avoid that it overlaps title bar buttons
|
||||
int tw = Math.min( titlePane.getPreferredSize().width, width );
|
||||
mw -= tw;
|
||||
if( !titlePane.getComponentOrientation().isLeftToRight() )
|
||||
mx = tw;
|
||||
}
|
||||
|
||||
Dimension prefSize = menuBar.getPreferredSize();
|
||||
menuBar.setBounds( 0, nextY, width, prefSize.height );
|
||||
menuBar.setBounds( mx, nextY, mw, prefSize.height );
|
||||
nextY += prefSize.height;
|
||||
}
|
||||
}
|
||||
|
||||
// content pane
|
||||
// content pane (is a child of layered pane)
|
||||
Container contentPane = rootPane.getContentPane();
|
||||
if( contentPane != null )
|
||||
contentPane.setBounds( 0, nextY, width, Math.max( height - nextY, 0 ) );
|
||||
|
||||
@@ -36,6 +36,7 @@ import java.awt.Rectangle;
|
||||
import java.awt.Toolkit;
|
||||
import java.awt.Window;
|
||||
import java.awt.event.ActionListener;
|
||||
import java.awt.event.ComponentAdapter;
|
||||
import java.awt.event.ComponentEvent;
|
||||
import java.awt.event.ComponentListener;
|
||||
import java.awt.event.MouseEvent;
|
||||
@@ -46,7 +47,6 @@ import java.awt.event.WindowEvent;
|
||||
import java.awt.geom.AffineTransform;
|
||||
import java.beans.PropertyChangeEvent;
|
||||
import java.beans.PropertyChangeListener;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Objects;
|
||||
import javax.accessibility.AccessibleContext;
|
||||
@@ -57,7 +57,6 @@ import javax.swing.Icon;
|
||||
import javax.swing.JButton;
|
||||
import javax.swing.JComponent;
|
||||
import javax.swing.JDialog;
|
||||
import javax.swing.JInternalFrame;
|
||||
import javax.swing.JLabel;
|
||||
import javax.swing.JMenuBar;
|
||||
import javax.swing.JPanel;
|
||||
@@ -98,7 +97,6 @@ import com.formdev.flatlaf.util.UIScale;
|
||||
* @uiDefault TitlePane.showIconBesideTitle boolean
|
||||
* @uiDefault TitlePane.menuBarTitleGap int
|
||||
* @uiDefault TitlePane.menuBarTitleMinimumGap int
|
||||
* @uiDefault TitlePane.menuBarResizeHeight int
|
||||
* @uiDefault TitlePane.closeIcon Icon
|
||||
* @uiDefault TitlePane.iconifyIcon Icon
|
||||
* @uiDefault TitlePane.maximizeIcon Icon
|
||||
@@ -109,7 +107,7 @@ import com.formdev.flatlaf.util.UIScale;
|
||||
public class FlatTitlePane
|
||||
extends JComponent
|
||||
{
|
||||
private static final String KEY_DEBUG_SHOW_RECTANGLES = "FlatLaf.debug.titlebar.showRectangles";
|
||||
static final String KEY_DEBUG_SHOW_RECTANGLES = "FlatLaf.debug.titlebar.showRectangles";
|
||||
|
||||
/** @since 2.5 */ protected final Font titleFont;
|
||||
protected final Color activeBackground;
|
||||
@@ -131,7 +129,6 @@ public class FlatTitlePane
|
||||
/** @since 2.4 */ protected final boolean showIconBesideTitle;
|
||||
protected final int menuBarTitleGap;
|
||||
/** @since 2.4 */ protected final int menuBarTitleMinimumGap;
|
||||
/** @since 2.4 */ protected final int menuBarResizeHeight;
|
||||
|
||||
protected final JRootPane rootPane;
|
||||
protected final String windowStyle;
|
||||
@@ -150,6 +147,23 @@ public class FlatTitlePane
|
||||
|
||||
private final Handler handler;
|
||||
|
||||
/**
|
||||
* This panel handles mouse events if FlatLaf window decorations are used
|
||||
* without native window border. E.g. on Linux.
|
||||
* <p>
|
||||
* This panel usually has same bounds as the title pane,
|
||||
* except if fullWindowContent mode is enabled.
|
||||
* <p>
|
||||
* This panel is not a child of the title pane.
|
||||
* Instead it is added by FlatRootPaneUI to the layered pane at a layer
|
||||
* under the title pane and under the frame content.
|
||||
* The separation is necessary for fullWindowContent mode, where the title pane
|
||||
* is layered over the frame content (for title pane buttons), but the mousePanel
|
||||
* needs to be layered under the frame content so that components on content pane
|
||||
* can receive mouse events when located in title area.
|
||||
*/
|
||||
final JPanel mouseLayer;
|
||||
|
||||
public FlatTitlePane( JRootPane rootPane ) {
|
||||
this.rootPane = rootPane;
|
||||
|
||||
@@ -178,7 +192,6 @@ public class FlatTitlePane
|
||||
showIconBesideTitle = FlatUIUtils.getSubUIBoolean( "TitlePane.showIconBesideTitle", windowStyle, false );
|
||||
menuBarTitleGap = FlatUIUtils.getSubUIInt( "TitlePane.menuBarTitleGap", windowStyle, 40 );
|
||||
menuBarTitleMinimumGap = FlatUIUtils.getSubUIInt( "TitlePane.menuBarTitleMinimumGap", windowStyle, 12 );
|
||||
menuBarResizeHeight = FlatUIUtils.getSubUIInt( "TitlePane.menuBarResizeHeight", windowStyle, 4 );
|
||||
|
||||
|
||||
handler = createHandler();
|
||||
@@ -187,11 +200,10 @@ public class FlatTitlePane
|
||||
addSubComponents();
|
||||
activeChanged( true );
|
||||
|
||||
addMouseListener( handler );
|
||||
addMouseMotionListener( handler );
|
||||
|
||||
// necessary for closing window with double-click on icon
|
||||
iconLabel.addMouseListener( handler );
|
||||
mouseLayer = new JPanel();
|
||||
mouseLayer.setOpaque( false );
|
||||
mouseLayer.addMouseListener( handler );
|
||||
mouseLayer.addMouseMotionListener( handler );
|
||||
|
||||
applyComponentOrientation( rootPane.getComponentOrientation() );
|
||||
}
|
||||
@@ -234,6 +246,11 @@ public class FlatTitlePane
|
||||
setLayout( new BorderLayout() {
|
||||
@Override
|
||||
public void layoutContainer( Container target ) {
|
||||
if( isFullWindowContent() ) {
|
||||
super.layoutContainer( target );
|
||||
return;
|
||||
}
|
||||
|
||||
// compute available bounds
|
||||
Insets insets = target.getInsets();
|
||||
int x = insets.left;
|
||||
@@ -247,7 +264,7 @@ public class FlatTitlePane
|
||||
int titleWidth = w - leftWidth - buttonsWidth;
|
||||
int minTitleWidth = UIScale.scale( titleMinimumWidth );
|
||||
|
||||
// increase minimum width if icon is show besides the title
|
||||
// increase minimum width if icon is shown besides the title
|
||||
Icon icon = titleLabel.getIcon();
|
||||
if( icon != null ) {
|
||||
Insets iconInsets = iconLabel.getInsets();
|
||||
@@ -295,6 +312,9 @@ public class FlatTitlePane
|
||||
horizontalGlue.getWidth(), titleLabel.getHeight() );
|
||||
}
|
||||
}
|
||||
|
||||
// clear hit-test cache
|
||||
lastHitTestTime = 0;
|
||||
}
|
||||
} );
|
||||
|
||||
@@ -337,6 +357,10 @@ public class FlatTitlePane
|
||||
buttonPanel.add( maximizeButton );
|
||||
buttonPanel.add( restoreButton );
|
||||
}
|
||||
buttonPanel.addComponentListener( new ComponentAdapter() {
|
||||
@Override public void componentResized( ComponentEvent e ) { updateFullWindowContentButtonsBoundsProperty(); }
|
||||
@Override public void componentMoved( ComponentEvent e ) { updateFullWindowContentButtonsBoundsProperty(); }
|
||||
} );
|
||||
buttonPanel.add( closeButton );
|
||||
}
|
||||
|
||||
@@ -417,7 +441,9 @@ public class FlatTitlePane
|
||||
|
||||
/** @since 3 */
|
||||
protected void updateVisibility() {
|
||||
titleLabel.setVisible( clientPropertyBoolean( rootPane, TITLE_BAR_SHOW_TITLE, true ) );
|
||||
boolean isFullWindowContent = isFullWindowContent();
|
||||
leftPanel.setVisible( !isFullWindowContent );
|
||||
titleLabel.setVisible( clientPropertyBoolean( rootPane, TITLE_BAR_SHOW_TITLE, true ) && !isFullWindowContent );
|
||||
closeButton.setVisible( clientPropertyBoolean( rootPane, TITLE_BAR_SHOW_CLOSE, true ) );
|
||||
|
||||
if( window instanceof Frame ) {
|
||||
@@ -443,7 +469,7 @@ public class FlatTitlePane
|
||||
|
||||
// get window images
|
||||
List<Image> images = null;
|
||||
if( clientPropertyBoolean( rootPane, TITLE_BAR_SHOW_ICON, defaultShowIcon ) ) {
|
||||
if( clientPropertyBoolean( rootPane, TITLE_BAR_SHOW_ICON, defaultShowIcon ) && !isFullWindowContent() ) {
|
||||
images = window.getIconImages();
|
||||
if( images.isEmpty() ) {
|
||||
// search in owners
|
||||
@@ -468,6 +494,13 @@ public class FlatTitlePane
|
||||
updateNativeTitleBarHeightAndHitTestSpotsLater();
|
||||
}
|
||||
|
||||
void updateFullWindowContentButtonsBoundsProperty() {
|
||||
Rectangle bounds = isFullWindowContent()
|
||||
? new Rectangle( SwingUtilities.convertPoint( buttonPanel, 0, 0, rootPane ), buttonPanel.getSize() )
|
||||
: null;
|
||||
rootPane.putClientProperty( FlatClientProperties.FULL_WINDOW_CONTENT_BUTTONS_BOUNDS, bounds );
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addNotify() {
|
||||
super.addNotify();
|
||||
@@ -522,6 +555,11 @@ public class FlatTitlePane
|
||||
window.removeComponentListener( handler );
|
||||
}
|
||||
|
||||
/** @since 3.4 */
|
||||
protected boolean isFullWindowContent() {
|
||||
return FlatRootPaneUI.isFullWindowContent( rootPane );
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether this title pane currently has a visible and embedded menubar.
|
||||
*/
|
||||
@@ -533,6 +571,9 @@ public class FlatTitlePane
|
||||
* Returns whether the menubar should be embedded into the title pane.
|
||||
*/
|
||||
protected boolean isMenuBarEmbedded() {
|
||||
if( isFullWindowContent() )
|
||||
return false;
|
||||
|
||||
// not storing value of "TitlePane.menuBarEmbedded" in class to allow changing at runtime
|
||||
return FlatUIUtils.getBoolean( rootPane,
|
||||
FlatSystemProperties.MENUBAR_EMBEDDED,
|
||||
@@ -620,21 +661,45 @@ public class FlatTitlePane
|
||||
return;
|
||||
|
||||
if( debugTitleBarHeight > 0 ) {
|
||||
// title bar height is measured from window top edge
|
||||
int y = SwingUtilities.convertPoint( window, 0, debugTitleBarHeight, this ).y;
|
||||
g.setColor( Color.green );
|
||||
g.drawLine( 0, debugTitleBarHeight, getWidth(), debugTitleBarHeight );
|
||||
g.drawLine( 0, y, getWidth(), y );
|
||||
}
|
||||
if( debugHitTestSpots != null ) {
|
||||
for( Rectangle r : debugHitTestSpots )
|
||||
paintRect( g, Color.red, r );
|
||||
}
|
||||
paintRect( g, Color.cyan, debugCloseButtonBounds );
|
||||
paintRect( g, Color.blue, debugAppIconBounds );
|
||||
paintRect( g, Color.blue, debugMinimizeButtonBounds );
|
||||
paintRect( g, Color.magenta, debugMaximizeButtonBounds );
|
||||
paintRect( g, Color.cyan, debugCloseButtonBounds );
|
||||
|
||||
g.setColor( Color.red );
|
||||
debugPaintComponentWithMouseListener( g, Color.red, rootPane.getLayeredPane(), 0, 0 );
|
||||
|
||||
debugPaintRect( g, Color.blue, debugAppIconBounds );
|
||||
debugPaintRect( g, Color.blue, debugMinimizeButtonBounds );
|
||||
debugPaintRect( g, Color.magenta, debugMaximizeButtonBounds );
|
||||
debugPaintRect( g, Color.cyan, debugCloseButtonBounds );
|
||||
}
|
||||
|
||||
private void paintRect( Graphics g, Color color, Rectangle r ) {
|
||||
private void debugPaintComponentWithMouseListener( Graphics g, Color color, Component c, int x, int y ) {
|
||||
if( !c.isDisplayable() || !c.isVisible() || c == mouseLayer ||
|
||||
c == iconifyButton || c == maximizeButton || c == restoreButton || c == closeButton )
|
||||
return;
|
||||
|
||||
if( c.getMouseListeners().length > 0 ||
|
||||
c.getMouseMotionListeners().length > 0 ||
|
||||
c.getMouseWheelListeners().length > 0 )
|
||||
{
|
||||
g.drawRect( x, y, c.getWidth(), c.getHeight() );
|
||||
return;
|
||||
}
|
||||
|
||||
if( c instanceof Container ) {
|
||||
Rectangle titlePaneBoundsOnWindow = SwingUtilities.convertRectangle( this, new Rectangle( getSize() ), window );
|
||||
for( Component child : ((Container)c).getComponents() ) {
|
||||
Rectangle compBoundsOnWindow = SwingUtilities.convertRectangle( c, new Rectangle( c.getSize() ), window );
|
||||
if( compBoundsOnWindow.intersects( titlePaneBoundsOnWindow ) )
|
||||
debugPaintComponentWithMouseListener( g, color, child, x + child.getX(), y + child.getY() );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void debugPaintRect( Graphics g, Color color, Rectangle r ) {
|
||||
if( r == null )
|
||||
return;
|
||||
|
||||
@@ -645,6 +710,9 @@ public class FlatTitlePane
|
||||
|
||||
@Override
|
||||
protected void paintComponent( Graphics g ) {
|
||||
if( isFullWindowContent() )
|
||||
return;
|
||||
|
||||
// not storing value of "TitlePane.unifiedBackground" in class to allow changing at runtime
|
||||
g.setColor( (UIManager.getBoolean( "TitlePane.unifiedBackground" ) &&
|
||||
clientPropertyColor( rootPane, TITLE_BAR_BACKGROUND, null ) == null)
|
||||
@@ -866,11 +934,14 @@ public class FlatTitlePane
|
||||
return;
|
||||
|
||||
int titleBarHeight = getHeight();
|
||||
// title bar height must be measured from window top edge
|
||||
// (when window is maximized, window y location is e.g. -11 and window top inset is 11)
|
||||
for( Component c = this; c != window && c != null; c = c.getParent() )
|
||||
titleBarHeight += c.getY();
|
||||
// slightly reduce height so that component receives mouseExit events
|
||||
if( titleBarHeight > 0 )
|
||||
titleBarHeight--;
|
||||
|
||||
List<Rectangle> hitTestSpots = new ArrayList<>();
|
||||
Rectangle appIconBounds = null;
|
||||
|
||||
if( !showIconBesideTitle && iconLabel.isVisible() ) {
|
||||
@@ -928,71 +999,17 @@ public class FlatTitlePane
|
||||
}
|
||||
}
|
||||
|
||||
Rectangle r = getNativeHitTestSpot( buttonPanel );
|
||||
if( r != null )
|
||||
hitTestSpots.add( r );
|
||||
|
||||
JMenuBar menuBar = rootPane.getJMenuBar();
|
||||
if( hasVisibleEmbeddedMenuBar( menuBar ) ) {
|
||||
r = getNativeHitTestSpot( menuBar );
|
||||
if( r != null ) {
|
||||
// if frame is resizable and not maximized, make menu bar hit test spot smaller at top
|
||||
// to have a small area above the menu bar to resize the window
|
||||
if( window instanceof Frame && ((Frame)window).isResizable() && !isWindowMaximized() ) {
|
||||
// limit to 8, because Windows does not use a larger height
|
||||
int resizeHeight = UIScale.scale( Math.min( menuBarResizeHeight, 8 ) );
|
||||
r.y += resizeHeight;
|
||||
r.height -= resizeHeight;
|
||||
}
|
||||
|
||||
int count = menuBar.getComponentCount();
|
||||
for( int i = count - 1; i >= 0; i-- ) {
|
||||
Component c = menuBar.getComponent( i );
|
||||
if( c instanceof Box.Filler ||
|
||||
(c instanceof JComponent && clientPropertyBoolean( (JComponent) c, COMPONENT_TITLE_BAR_CAPTION, false ) ) )
|
||||
{
|
||||
// If menu bar is embedded and contains a horizontal glue or caption component,
|
||||
// then split the hit test spot so that
|
||||
// the glue/caption component area can be used to move the window.
|
||||
|
||||
Point glueLocation = SwingUtilities.convertPoint( c, 0, 0, window );
|
||||
int x2 = glueLocation.x + c.getWidth();
|
||||
Rectangle r2;
|
||||
if( getComponentOrientation().isLeftToRight() ) {
|
||||
r2 = new Rectangle( x2, r.y, (r.x + r.width) - x2, r.height );
|
||||
|
||||
r.width = glueLocation.x - r.x;
|
||||
} else {
|
||||
r2 = new Rectangle( r.x, r.y, glueLocation.x - r.x, r.height );
|
||||
|
||||
r.width = (r.x + r.width) - x2;
|
||||
r.x = x2;
|
||||
}
|
||||
if( r2.width > 0 )
|
||||
hitTestSpots.add( r2 );
|
||||
}
|
||||
}
|
||||
|
||||
hitTestSpots.add( r );
|
||||
}
|
||||
}
|
||||
|
||||
// allow internal frames in layered pane to be moved/resized when placed over title bar
|
||||
for( Component c : rootPane.getLayeredPane().getComponents() ) {
|
||||
r = (c instanceof JInternalFrame) ? getNativeHitTestSpot( (JInternalFrame) c ) : null;
|
||||
if( r != null )
|
||||
hitTestSpots.add( r );
|
||||
}
|
||||
|
||||
Rectangle minimizeButtonBounds = boundsInWindow( iconifyButton );
|
||||
Rectangle maximizeButtonBounds = boundsInWindow( maximizeButton.isVisible() ? maximizeButton : restoreButton );
|
||||
Rectangle closeButtonBounds = boundsInWindow( closeButton );
|
||||
|
||||
// clear hit-test cache
|
||||
lastHitTestTime = 0;
|
||||
|
||||
FlatNativeWindowBorder.setTitleBarHeightAndHitTestSpots( window, titleBarHeight,
|
||||
hitTestSpots, appIconBounds, minimizeButtonBounds, maximizeButtonBounds, closeButtonBounds );
|
||||
this::hitTest, appIconBounds, minimizeButtonBounds, maximizeButtonBounds, closeButtonBounds );
|
||||
|
||||
debugTitleBarHeight = titleBarHeight;
|
||||
debugHitTestSpots = hitTestSpots;
|
||||
debugAppIconBounds = appIconBounds;
|
||||
debugMinimizeButtonBounds = minimizeButtonBounds;
|
||||
debugMaximizeButtonBounds = maximizeButtonBounds;
|
||||
@@ -1017,8 +1034,66 @@ public class FlatTitlePane
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns wheter there is a component at the given location, that processes
|
||||
* mouse events. E.g. buttons, menus, etc.
|
||||
* <p>
|
||||
* Note:
|
||||
* <ul>
|
||||
* <li>This method is invoked often when mouse is moved over title bar
|
||||
* and should therefore return quickly.
|
||||
* <li>This method is invoked on 'AWT-Windows' thread (not 'AWT-EventQueue' thread)
|
||||
* while processing Windows messages.
|
||||
* </ul>
|
||||
*/
|
||||
private boolean hitTest( Point pt ) {
|
||||
// Windows invokes this method every ~200ms, even if the mouse has not moved
|
||||
long time = System.currentTimeMillis();
|
||||
if( pt.x == lastHitTestX && pt.y == lastHitTestY && time < lastHitTestTime + 300 ) {
|
||||
lastHitTestTime = time;
|
||||
return lastHitTestResult;
|
||||
}
|
||||
|
||||
// convert pt from window coordinates to layeredPane coordinates
|
||||
Component layeredPane = rootPane.getLayeredPane();
|
||||
int x = pt.x;
|
||||
int y = pt.y;
|
||||
for( Component c = layeredPane; c != window && c != null; c = c.getParent() ) {
|
||||
x -= c.getX();
|
||||
y -= c.getY();
|
||||
}
|
||||
|
||||
lastHitTestX = pt.x;
|
||||
lastHitTestY = pt.y;
|
||||
lastHitTestTime = time;
|
||||
lastHitTestResult = isComponentWithMouseListenerAt( layeredPane, x, y );
|
||||
return lastHitTestResult;
|
||||
}
|
||||
|
||||
private boolean isComponentWithMouseListenerAt( Component c, int x, int y ) {
|
||||
if( !c.isDisplayable() || !c.isVisible() || !c.contains( x, y ) || c == mouseLayer )
|
||||
return false;
|
||||
|
||||
if( c.getMouseListeners().length > 0 ||
|
||||
c.getMouseMotionListeners().length > 0 ||
|
||||
c.getMouseWheelListeners().length > 0 )
|
||||
return true;
|
||||
|
||||
if( c instanceof Container ) {
|
||||
for( Component child : ((Container)c).getComponents() ) {
|
||||
if( isComponentWithMouseListenerAt( child, x - child.getX(), y - child.getY() ) )
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private int lastHitTestX;
|
||||
private int lastHitTestY;
|
||||
private long lastHitTestTime;
|
||||
private boolean lastHitTestResult;
|
||||
|
||||
private int debugTitleBarHeight;
|
||||
private List<Rectangle> debugHitTestSpots;
|
||||
private Rectangle debugAppIconBounds;
|
||||
private Rectangle debugMinimizeButtonBounds;
|
||||
private Rectangle debugMaximizeButtonBounds;
|
||||
@@ -1116,7 +1191,7 @@ public class FlatTitlePane
|
||||
}
|
||||
}
|
||||
|
||||
// compute icon width and gap (if icon is show besides the title)
|
||||
// compute icon width and gap (if icon is shown besides the title)
|
||||
int iconTextGap = 0;
|
||||
int iconWidthAndGap = 0;
|
||||
if( icon != null ) {
|
||||
@@ -1125,7 +1200,7 @@ public class FlatTitlePane
|
||||
iconWidthAndGap = icon.getIconWidth() + iconTextGap;
|
||||
}
|
||||
|
||||
// layout title and icon (if show besides the title)
|
||||
// layout title and icon (if shown besides the title)
|
||||
String clippedText = SwingUtilities.layoutCompoundLabel( label, fontMetrics, text, icon,
|
||||
label.getVerticalAlignment(), label.getHorizontalAlignment(),
|
||||
label.getVerticalTextPosition(), label.getHorizontalTextPosition(),
|
||||
@@ -1275,7 +1350,7 @@ debug*/
|
||||
}
|
||||
|
||||
if( e.getClickCount() == 2 && SwingUtilities.isLeftMouseButton( e ) ) {
|
||||
if( e.getSource() == iconLabel ) {
|
||||
if( SwingUtilities.getDeepestComponentAt( FlatTitlePane.this, e.getX(), e.getY() ) == iconLabel ) {
|
||||
// double-click on icon closes window
|
||||
close();
|
||||
} else if( !hasNativeCustomDecoration() ) {
|
||||
@@ -1302,7 +1377,7 @@ debug*/
|
||||
if( !SwingUtilities.isLeftMouseButton( e ) )
|
||||
return;
|
||||
|
||||
dragOffset = SwingUtilities.convertPoint( FlatTitlePane.this, e.getPoint(), window );
|
||||
dragOffset = SwingUtilities.convertPoint( mouseLayer, e.getPoint(), window );
|
||||
linuxNativeMove = false;
|
||||
|
||||
// on Linux, move or maximize/restore window
|
||||
|
||||
@@ -29,8 +29,8 @@ import java.beans.PropertyChangeEvent;
|
||||
import java.beans.PropertyChangeListener;
|
||||
import java.util.Collections;
|
||||
import java.util.IdentityHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.function.Predicate;
|
||||
import javax.swing.JDialog;
|
||||
import javax.swing.JFrame;
|
||||
import javax.swing.Timer;
|
||||
@@ -159,7 +159,7 @@ class FlatWindowsNativeWindowBorder
|
||||
}
|
||||
|
||||
@Override
|
||||
public void updateTitleBarInfo( Window window, int titleBarHeight, List<Rectangle> hitTestSpots,
|
||||
public void updateTitleBarInfo( Window window, int titleBarHeight, Predicate<Point> hitTestCallback,
|
||||
Rectangle appIconBounds, Rectangle minimizeButtonBounds, Rectangle maximizeButtonBounds,
|
||||
Rectangle closeButtonBounds )
|
||||
{
|
||||
@@ -168,7 +168,7 @@ class FlatWindowsNativeWindowBorder
|
||||
return;
|
||||
|
||||
wndProc.titleBarHeight = titleBarHeight;
|
||||
wndProc.hitTestSpots = hitTestSpots.toArray( new Rectangle[hitTestSpots.size()] );
|
||||
wndProc.hitTestCallback = hitTestCallback;
|
||||
wndProc.appIconBounds = cloneRectange( appIconBounds );
|
||||
wndProc.minimizeButtonBounds = cloneRectange( minimizeButtonBounds );
|
||||
wndProc.maximizeButtonBounds = cloneRectange( maximizeButtonBounds );
|
||||
@@ -288,8 +288,8 @@ class FlatWindowsNativeWindowBorder
|
||||
private final long hwnd;
|
||||
|
||||
// Swing coordinates/values may be scaled on a HiDPI screen
|
||||
private int titleBarHeight;
|
||||
private Rectangle[] hitTestSpots;
|
||||
private int titleBarHeight; // measured from window top edge, which may be out-of-screen if maximized
|
||||
private Predicate<Point> hitTestCallback;
|
||||
private Rectangle appIconBounds;
|
||||
private Rectangle minimizeButtonBounds;
|
||||
private Rectangle maximizeButtonBounds;
|
||||
@@ -340,50 +340,61 @@ class FlatWindowsNativeWindowBorder
|
||||
private int onNcHitTest( int x, int y, boolean isOnResizeBorder ) {
|
||||
// scale-down mouse x/y because Swing coordinates/values may be scaled on a HiDPI screen
|
||||
Point pt = scaleDown( x, y );
|
||||
int sx = pt.x;
|
||||
int sy = pt.y;
|
||||
|
||||
// return HTSYSMENU if mouse is over application icon
|
||||
// - left-click on HTSYSMENU area shows system menu
|
||||
// - double-left-click sends WM_CLOSE
|
||||
if( contains( appIconBounds, sx, sy ) )
|
||||
if( contains( appIconBounds, pt ) )
|
||||
return HTSYSMENU;
|
||||
|
||||
// return HTMINBUTTON if mouse is over minimize button
|
||||
// - hovering mouse over HTMINBUTTON area shows tooltip on Windows 10/11
|
||||
if( contains( minimizeButtonBounds, sx, sy ) )
|
||||
if( contains( minimizeButtonBounds, pt ) )
|
||||
return HTMINBUTTON;
|
||||
|
||||
// return HTMAXBUTTON if mouse is over maximize/restore button
|
||||
// - hovering mouse over HTMAXBUTTON area shows tooltip on Windows 10
|
||||
// - hovering mouse over HTMAXBUTTON area shows snap layouts menu on Windows 11
|
||||
// https://docs.microsoft.com/en-us/windows/apps/desktop/modernize/apply-snap-layout-menu
|
||||
if( contains( maximizeButtonBounds, sx, sy ) )
|
||||
if( contains( maximizeButtonBounds, pt ) )
|
||||
return HTMAXBUTTON;
|
||||
|
||||
// return HTCLOSE if mouse is over close button
|
||||
// - hovering mouse over HTCLOSE area shows tooltip on Windows 10/11
|
||||
if( contains( closeButtonBounds, sx, sy ) )
|
||||
if( contains( closeButtonBounds, pt ) )
|
||||
return HTCLOSE;
|
||||
|
||||
boolean isOnTitleBar = (sy < titleBarHeight);
|
||||
// return HTTOP if mouse is over top resize border
|
||||
// - hovering mouse shows vertical resize cursor
|
||||
// - left-click and drag vertically resizes window
|
||||
if( isOnResizeBorder )
|
||||
return HTTOP;
|
||||
|
||||
boolean isOnTitleBar = (pt.y < titleBarHeight);
|
||||
if( isOnTitleBar ) {
|
||||
// use a second reference to the array to avoid that it can be changed
|
||||
// in another thread while processing the array
|
||||
Rectangle[] hitTestSpots2 = hitTestSpots;
|
||||
for( Rectangle spot : hitTestSpots2 ) {
|
||||
if( spot.contains( sx, sy ) )
|
||||
// return HTCLIENT if mouse is over any Swing component in title bar
|
||||
// that processes mouse events (e.g. buttons, menus, etc)
|
||||
// - Windows ignores mouse events in this area
|
||||
try {
|
||||
if( hitTestCallback != null && hitTestCallback.test( pt ) )
|
||||
return HTCLIENT;
|
||||
} catch( Throwable ex ) {
|
||||
// ignore
|
||||
}
|
||||
return isOnResizeBorder ? HTTOP : HTCAPTION;
|
||||
|
||||
// return HTCAPTION if mouse is over title bar
|
||||
// - right-click shows system menu
|
||||
// - double-left-click maximizes/restores window size
|
||||
return HTCAPTION;
|
||||
}
|
||||
|
||||
return isOnResizeBorder ? HTTOP : HTCLIENT;
|
||||
// return HTCLIENT
|
||||
// - Windows ignores mouse events in this area
|
||||
return HTCLIENT;
|
||||
}
|
||||
|
||||
private boolean contains( Rectangle rect, int x, int y ) {
|
||||
return (rect != null && rect.contains( x, y ) );
|
||||
private boolean contains( Rectangle rect, Point pt ) {
|
||||
return (rect != null && rect.contains( pt ) );
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -829,7 +829,6 @@ TitlePane.centerTitleIfMenuBarEmbedded = true
|
||||
TitlePane.showIconBesideTitle = false
|
||||
TitlePane.menuBarTitleGap = 40
|
||||
TitlePane.menuBarTitleMinimumGap = 12
|
||||
TitlePane.menuBarResizeHeight = 4
|
||||
TitlePane.closeIcon = com.formdev.flatlaf.icons.FlatWindowCloseIcon
|
||||
TitlePane.iconifyIcon = com.formdev.flatlaf.icons.FlatWindowIconifyIcon
|
||||
TitlePane.maximizeIcon = com.formdev.flatlaf.icons.FlatWindowMaximizeIcon
|
||||
|
||||
Reference in New Issue
Block a user