com.alee.utils.CoreSwingUtils Maven / Gradle / Ivy
The newest version!
/*
* This file is part of WebLookAndFeel library.
*
* WebLookAndFeel library is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* WebLookAndFeel library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with WebLookAndFeel library. If not, see getPopupMenus ()
{
final MenuElement[] selected = MenuSelectionManager.defaultManager ().getSelectedPath ();
final List menus = new ArrayList ( selected.length );
for ( final MenuElement element : selected )
{
if ( element instanceof JPopupMenu )
{
menus.add ( ( JPopupMenu ) element );
}
}
return menus;
}
/**
* Returns whether or not specified {@link InputEvent} contains a menu shortcut key.
*
* @param event {@link InputEvent}
* @return {@code true} if specified {@link InputEvent} contains a menu shortcut key, {@code false} otherwise
*/
public static boolean isMenuShortcutKeyDown ( @NotNull final InputEvent event )
{
return ( event.getModifiers () & Toolkit.getDefaultToolkit ().getMenuShortcutKeyMask () ) != 0;
}
/**
* Returns whether or not current thread is an AWT event dispatching thread.
*
* @return {@code true} if the current thread is an AWT event dispatching thread, {@code false} otherwise
*/
public static boolean isEventDispatchThread ()
{
return SwingUtilities.isEventDispatchThread ();
}
/**
* Will invoke specified {@link Runnable} later in EDT.
* It is highly recommended to perform all UI-related operations within EDT by invoking them through this method.
*
* @param runnable {@link Runnable} to execute
*/
public static void invokeLater ( @NotNull final Runnable runnable )
{
SwingUtilities.invokeLater ( runnable );
}
/**
* Executes specified {@link Runnable} on the current {@link Thread} if it is Event Dispatch Thread.
* Otherwise specified {@link Runnable} will be executed later on Event Dispatch Thread.
*
* @param runnable {@link Runnable} to execute
*/
public static void invokeOnEventDispatchThread ( @NotNull final Runnable runnable )
{
if ( CoreSwingUtils.isEventDispatchThread () )
{
runnable.run ();
}
else
{
invokeLater ( runnable );
}
}
/**
* Will invoke the specified {@link Runnable} in EDT in case it is called from non-EDT thread.
* It will catch any exceptions thrown by {@link SwingUtilities#invokeAndWait(Runnable)} and wrap them in {@link UtilityException}.
* It is generally recommended to use {@link #invokeLater(Runnable)} instead whenever it is possible to avoid stalling EDT.
*
* @param runnable {@link Runnable} to execute
*/
public static void invokeAndWait ( @NotNull final Runnable runnable )
{
invokeAndWait ( runnable, false );
}
/**
* Will invoke the specified {@link Runnable} in EDT in case it is called from non-EDT thread.
* It will catch any exceptions thrown by {@link SwingUtilities#invokeAndWait(Runnable)} and wrap them in {@link UtilityException}.
* It is generally recommended to use {@link #invokeLater(Runnable)} instead whenever it is possible to avoid stalling EDT.
*
* @param runnable {@link Runnable} to execute
* @param ignoreInterrupts whether or not {@link InterruptedException}s should be ignored
*/
public static void invokeAndWait ( @NotNull final Runnable runnable, final boolean ignoreInterrupts )
{
try
{
if ( SwingUtilities.isEventDispatchThread () )
{
// This is reasonable since we can't invoke and wait if we are already on EDT
runnable.run ();
}
else
{
// If we aren't on EDT we should queue runnable execution
SwingUtilities.invokeAndWait ( runnable );
}
}
catch ( final InvocationTargetException e )
{
// Re-throw wrapped exception
throw new UtilityException ( e );
}
catch ( final InterruptedException e )
{
if ( !ignoreInterrupts )
{
// Re-throw wrapped exception
throw new UtilityException ( e );
}
}
}
/**
* Returns intersection of the visible rectangles for the component and all of its ancestors.
*
* @param component {@link Component}
* @return intersection of the visible rectangles for the component and all of its ancestors
*/
@NotNull
public static Rectangle getVisibleRect ( @NotNull final Component component )
{
return component instanceof JComponent ?
( ( JComponent ) component ).getVisibleRect () :
computeVisibleRect ( component, new Rectangle () );
}
/**
* Returns intersection of the visible rectangles for the component and all of its ancestors.
* Return value is also stored in {@code visibleRect}.
* This is a copy of private {@code JComponent#computeVisibleRect(Component, Rectangle)} method.
*
* @param component {@link Component}
* @param visibleRect {@code Rectangle} containing intersection of the visible rectangles for the component and all of its ancestors
* @return intersection of the visible rectangles for the component and all of its ancestors
*/
@NotNull
private static Rectangle computeVisibleRect ( @NotNull final Component component, @NotNull final Rectangle visibleRect )
{
final Container p = component.getParent ();
final Rectangle bounds = component.getBounds ();
if ( p == null || p instanceof Window || p instanceof Applet )
{
visibleRect.setBounds ( 0, 0, bounds.width, bounds.height );
}
else
{
computeVisibleRect ( p, visibleRect );
visibleRect.x -= bounds.x;
visibleRect.y -= bounds.y;
SwingUtilities.computeIntersection ( 0, 0, bounds.width, bounds.height, visibleRect );
}
return visibleRect;
}
} © 2015 - 2024 Weber Informatics LLC | Privacy Policy