public int getTitleHeight(Component c) {
int th = 21;
int fh = getBorderInsets(c).top + getBorderInsets(c).bottom;
if (c instanceof JDialog) {
JDialog dialog = (JDialog) c;
th = dialog.getSize().height - dialog.getContentPane().getSize().height - fh - 1;
if (dialog.getJMenuBar() != null) {
th -= dialog.getJMenuBar().getSize().height;
}
} else if (c instanceof JInternalFrame) {
JInternalFrame frame = (JInternalFrame) c;
th = frame.getSize().height - frame.getRootPane().getSize().height - fh - 1;
if (frame.getJMenuBar() != null) {
th -= frame.getJMenuBar().getSize().height;
}
} else if (c instanceof JRootPane) {
JRootPane jp = (JRootPane) c;
if (jp.getParent() instanceof JFrame) {
JFrame frame = (JFrame) c.getParent();
th = frame.getSize().height - frame.getContentPane().getSize().height - fh - 1;
if (frame.getJMenuBar() != null) {
th -= frame.getJMenuBar().getSize().height;
}
} else if (jp.getParent() instanceof JDialog) {
JDialog dialog = (JDialog) c.getParent();
th = dialog.getSize().height - dialog.getContentPane().getSize().height - fh - 1;
if (dialog.getJMenuBar() != null) {
th -= dialog.getJMenuBar().getSize().height;
}
}
}
return th;
}
private void adjustPositionForLookup(@NotNull Lookup lookup) {
if (!myHint.isVisible() || myEditor.isDisposed()) {
Disposer.dispose(this);
return;
}
IdeTooltip tooltip = myHint.getCurrentIdeTooltip();
if (tooltip != null) {
JRootPane root = myEditor.getComponent().getRootPane();
if (root != null) {
Point p = tooltip.getShowingPoint().getPoint(root.getLayeredPane());
if (lookup.isPositionedAboveCaret()) {
if (Position.above == tooltip.getPreferredPosition()) {
myHint.pack();
myHint.updatePosition(Position.below);
myHint.updateLocation(p.x, p.y + tooltip.getPositionChangeY());
}
} else {
if (Position.below == tooltip.getPreferredPosition()) {
myHint.pack();
myHint.updatePosition(Position.above);
myHint.updateLocation(p.x, p.y - tooltip.getPositionChangeY());
}
}
}
}
}
public void mouseMoved(MouseEvent ev) {
JRootPane root = getRootPane();
if (root.getWindowDecorationStyle() == JRootPane.NONE) {
return;
}
Window w = (Window) ev.getSource();
Frame f = null;
Dialog d = null;
if (w instanceof Frame) {
f = (Frame) w;
} else if (w instanceof Dialog) {
d = (Dialog) w;
}
// Update the cursor
int cursor = getCursor(calculateCorner(w, ev.getX(), ev.getY()));
if (cursor != 0
&& ((f != null && (f.isResizable() && (f.getExtendedState() & Frame.MAXIMIZED_BOTH) == 0))
|| (d != null && d.isResizable()))) {
w.setCursor(Cursor.getPredefinedCursor(cursor));
} else {
w.setCursor(lastCursor);
}
}
public WelcomeFrame() {
JRootPane rootPane = getRootPane();
final WelcomeScreen screen = createScreen(rootPane);
final IdeGlassPaneImpl glassPane = new IdeGlassPaneImpl(rootPane);
setGlassPane(glassPane);
glassPane.setVisible(false);
setContentPane(screen.getWelcomePanel());
setTitle(ApplicationNamesInfo.getInstance().getFullProductName());
AppUIUtil.updateWindowIcon(this);
ProjectManager.getInstance()
.addProjectManagerListener(
new ProjectManagerAdapter() {
@Override
public void projectOpened(Project project) {
dispose();
}
});
myBalloonLayout = new BalloonLayoutImpl(rootPane.getLayeredPane(), new Insets(8, 8, 8, 8));
myScreen = screen;
setupCloseAction();
new MnemonicHelper().register(this);
myScreen.setupFrame(this);
}
/**
* Returns the maximum amount of space the layout can use.
*
* @param the Container for which this layout manager is being used
* @return a Dimension object containing the layout's maximum size
*/
public Dimension maximumLayoutSize(Container target) {
Dimension cpd;
int cpWidth = Integer.MAX_VALUE;
int cpHeight = Integer.MAX_VALUE;
int mbWidth = Integer.MAX_VALUE;
int mbHeight = Integer.MAX_VALUE;
int tpWidth = Integer.MAX_VALUE;
int tpHeight = Integer.MAX_VALUE;
Insets i = target.getInsets();
JRootPane root = (JRootPane) target;
if (root.getContentPane() != null) {
cpd = root.getContentPane().getMaximumSize();
if (cpd != null) {
cpWidth = cpd.width;
cpHeight = cpd.height;
}
}
int maxHeight = Math.max(Math.max(cpHeight, mbHeight), tpHeight);
// Only overflows if 3 real non-MAX_VALUE heights, sum to > MAX_VALUE
// Only will happen if sums to more than 2 billion units. Not likely.
if (maxHeight != Integer.MAX_VALUE) {
maxHeight = cpHeight + mbHeight + tpHeight + i.top + i.bottom;
}
int maxWidth = Math.max(Math.max(cpWidth, mbWidth), tpWidth);
// Similar overflow comment as above
if (maxWidth != Integer.MAX_VALUE) {
maxWidth += i.left + i.right;
}
return new Dimension(maxWidth, maxHeight);
}
/**
* Returns the minimum amount of space the layout needs.
*
* @param the Container for which this layout manager is being used
* @return a Dimension object containing the layout's minimum size
*/
public Dimension minimumLayoutSize(Container parent) {
Dimension cpd;
int cpWidth = 0;
int cpHeight = 0;
int mbWidth = 0;
int mbHeight = 0;
int tpWidth = 0;
Insets i = parent.getInsets();
JRootPane root = (JRootPane) parent;
if (root.getContentPane() != null) {
cpd = root.getContentPane().getMinimumSize();
} else {
cpd = root.getSize();
}
if (cpd != null) {
cpWidth = cpd.width;
cpHeight = cpd.height;
}
return new Dimension(
Math.max(Math.max(cpWidth, mbWidth), tpWidth) + i.left + i.right,
cpHeight + mbHeight + tpWidth + i.top + i.bottom);
}
private void initWizard(final String title) {
setTitle(title);
myCurrentStep = 0;
myPreviousButton = new JButton(IdeBundle.message("button.wizard.previous"));
myNextButton = new JButton(IdeBundle.message("button.wizard.next"));
myCancelButton = new JButton(CommonBundle.getCancelButtonText());
myHelpButton = new JButton(CommonBundle.getHelpButtonText());
myContentPanel = new JPanel(new CardLayout());
myIcon = new TallImageComponent(null);
JRootPane rootPane = getRootPane();
if (rootPane != null) { // it will be null in headless mode, i.e. tests
rootPane.registerKeyboardAction(
new ActionListener() {
public void actionPerformed(final ActionEvent e) {
helpAction();
}
},
KeyStroke.getKeyStroke(KeyEvent.VK_F1, 0),
JComponent.WHEN_IN_FOCUSED_WINDOW);
rootPane.registerKeyboardAction(
new ActionListener() {
public void actionPerformed(final ActionEvent e) {
helpAction();
}
},
KeyStroke.getKeyStroke(KeyEvent.VK_HELP, 0),
JComponent.WHEN_IN_FOCUSED_WINDOW);
}
}
/**
* Invoked when a property changes. <code>MetalRootPaneUI</code> is primarily interested in events
* originating from the <code>JRootPane</code> it has been installed on identifying the property
* <code>windowDecorationStyle</code>. If the <code>windowDecorationStyle</code> has changed to a
* value other than <code>JRootPane.NONE</code>, this will add a <code>Component</code> to the
* <code>JRootPane</code> to render the window decorations, as well as installing a <code>Border
* </code> on the <code>JRootPane</code>. On the other hand, if the <code>windowDecorationStyle
* </code> has changed to <code>JRootPane.NONE</code>, this will remove the <code>Component</code>
* that has been added to the <code>JRootPane</code> as well resetting the Border to what it was
* before <code>installUI</code> was invoked.
*
* @param e A PropertyChangeEvent object describing the event source and the property that has
* changed.
*/
public void propertyChange(PropertyChangeEvent e) {
super.propertyChange(e);
String propertyName = e.getPropertyName();
if (propertyName == null) {
return;
}
if (propertyName.equals("windowDecorationStyle")) {
JRootPane root = (JRootPane) e.getSource();
int style = root.getWindowDecorationStyle();
// This is potentially more than needs to be done,
// but it rarely happens and makes the install/uninstall process
// simpler. MetalTitlePane also assumes it will be recreated if
// the decoration style changes.
uninstallClientDecorations(root);
if (style != JRootPane.NONE) {
installClientDecorations(root);
}
} else if (propertyName.equals("ancestor")) {
uninstallWindowListeners(root);
if (((JRootPane) e.getSource()).getWindowDecorationStyle() != JRootPane.NONE) {
installWindowListeners(root, root.getParent());
}
}
return;
}
/**
* Installs the appropriate LayoutManager on the <code>JRootPane</code> to render the window
* decorations.
*/
private void installLayout(JRootPane root) {
if (layoutManager == null) {
layoutManager = createLayoutManager();
}
savedOldLayout = root.getLayout();
root.setLayout(layoutManager);
}
/**
* Overrides <code>JComponent.removeNotify</code> to check if this button is currently set as the
* default button on the <code>RootPane</code>, and if so, sets the <code>RootPane</code>'s
* default button to <code>null</code> to ensure the <code>RootPane</code> doesn't hold onto an
* invalid button reference.
*/
public void removeNotify() {
JRootPane root = SwingUtilities.getRootPane(this);
if (root != null && root.getDefaultButton() == this) {
root.setDefaultButton(null);
}
super.removeNotify();
}
private boolean couldBeInFullScreen() {
if (myParent instanceof JFrame) {
JRootPane rootPane = ((JFrame) myParent).getRootPane();
return rootPane.getClientProperty(MacMainFrameDecorator.FULL_SCREEN) == null;
}
return false;
}
/**
* Gets the value of the <code>defaultButton</code> property, which if <code>true</code> means
* that this button is the current default button for its <code>JRootPane</code>. Most look and
* feels render the default button differently, and may potentially provide bindings to access the
* default button.
*
* @return the value of the <code>defaultButton</code> property
* @see JRootPane#setDefaultButton
* @see #isDefaultCapable
* @beaninfo description: Whether or not this button is the default button
*/
public boolean isDefaultButton() {
JRootPane root = SwingUtilities.getRootPane(this);
if (root != null) {
return root.getDefaultButton() == this;
}
return false;
}
@Override
public void setWindowShadow(Window window, WindowShadowMode mode) {
if (window instanceof JWindow) {
JRootPane root = ((JWindow) window).getRootPane();
root.putClientProperty(
"Window.shadow", mode == WindowShadowMode.DISABLED ? Boolean.FALSE : Boolean.TRUE);
root.putClientProperty("Window.style", mode == WindowShadowMode.SMALL ? "small" : null);
}
}
/** Called by the constructor methods to create the default rootPane. */
protected JRootPane createRootPane() {
JRootPane rp = new JRootPane();
// NOTE: this uses setOpaque vs LookAndFeel.installProperty as there
// is NO reason for the RootPane not to be opaque. For painting to
// work the contentPane must be opaque, therefor the RootPane can
// also be opaque.
rp.setOpaque(true);
return rp;
}
/** Installs the appropriate <code>Border</code> onto the <code>JRootPane</code>. */
void installBorder(JRootPane root) {
int style = root.getWindowDecorationStyle();
if (style == JRootPane.NONE) {
LookAndFeel.uninstallBorder(root);
} else {
root.setBorder(new RootPaneBorder());
}
}
private static boolean isHintsAllowed(Window window) {
if (window instanceof RootPaneContainer) {
final JRootPane pane = ((RootPaneContainer) window).getRootPane();
if (pane != null) {
return Boolean.TRUE.equals(pane.getClientProperty(AbstractPopup.SHOW_HINTS));
}
}
return false;
}
@Override
protected JRootPane createRootPane() {
JRootPane jrootPane = new JRootPane();
int menuShortcutKey = Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
KeyStroke w = KeyStroke.getKeyStroke(KeyEvent.VK_W, menuShortcutKey);
KeyStroke esc = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
jrootPane.registerKeyboardAction(this, ACTION_CLOSE, w, JComponent.WHEN_IN_FOCUSED_WINDOW);
jrootPane.registerKeyboardAction(this, ACTION_CLOSE, esc, JComponent.WHEN_IN_FOCUSED_WINDOW);
return jrootPane;
}
/**
* If inputComponent is non-null, the focus is requested on that, otherwise request focus on the
* default value
*/
public void selectInitialValue(JOptionPane op) {
if (inputComponent != null) inputComponent.requestFocus();
else {
if (initialFocusComponent != null) initialFocusComponent.requestFocus();
if (initialFocusComponent instanceof JButton) {
JRootPane root = SwingUtilities.getRootPane(initialFocusComponent);
if (root != null) {
root.setDefaultButton((JButton) initialFocusComponent);
}
}
}
}
private static Window pop(Window owner) {
JRootPane root = getRootPane(owner);
if (root != null) {
synchronized (CACHE) {
@SuppressWarnings("unchecked")
ArrayDeque<Window> cache = (ArrayDeque<Window>) root.getClientProperty(CACHE);
if (cache != null && !cache.isEmpty()) {
return cache.pop();
}
}
}
return null;
}
/**
* Installs the necessary state onto the JRootPane to render client decorations. This is ONLY
* invoked if the <code>JRootPane</code> has a decoration style other than <code>JRootPane.NONE
* </code>.
*/
private void installClientDecorations(JRootPane root) {
installBorder(root);
JComponent titlePane = createTitlePane(root);
setTitlePane(root, titlePane);
installWindowListeners(root, root.getParent());
installLayout(root);
if (window != null) {
root.revalidate();
root.repaint();
}
}
/**
* Called by the browser or applet viewer to inform this JApplet that it has been loaded into the
* system. It is always called before the first time that the start method is called.
*/
public void init() {
// this is a workaround for a security conflict with some browsers
// including some versions of Netscape & Internet Explorer which do
// not allow access to the AWT system event queue which JApplets do
// on startup to check access. May not be necessary with your browser.
JRootPane rootPane = this.getRootPane();
rootPane.putClientProperty("defeatSystemEventQueueCheck", Boolean.TRUE);
setLayout(new FlowLayout(FlowLayout.CENTER, 10, 10));
b1 = new Button("Choose this card");
add(b1);
b1.addActionListener(this);
// provide any initialisation necessary for your JApplet
}
@Nullable
public static LightweightHint showEditorFragmentHint(
Editor editor, TextRange range, boolean showFolding, boolean hideByAnyKey) {
JComponent editorComponent = editor.getComponent();
final JRootPane rootPane = editorComponent.getRootPane();
if (rootPane == null) return null;
JLayeredPane layeredPane = rootPane.getLayeredPane();
int x = -2;
int y = 0;
Point point = SwingUtilities.convertPoint(editorComponent, x, y, layeredPane);
return showEditorFragmentHintAt(
editor, range, point.x, point.y, true, showFolding, hideByAnyKey);
}
private static boolean isWindowTextured(final Component c) {
if (!(c instanceof JComponent)) {
return false;
}
final JRootPane pane = ((JComponent) c).getRootPane();
if (pane == null) {
return false;
}
Object prop = pane.getClientProperty(CPlatformWindow.WINDOW_BRUSH_METAL_LOOK);
if (prop != null) {
return Boolean.parseBoolean(prop.toString());
}
prop = pane.getClientProperty(CPlatformWindow.WINDOW_STYLE);
return prop != null && "textured".equals(prop);
}
private static JPanel createPanel(JFrame frame) {
JPanel panel = new JPanel();
JButton button = new JButton("Button");
JButton button2 = new JButton("Button 2");
JButton button3 = new JButton("Button 3");
JRootPane root = frame.getRootPane();
root.setDefaultButton(button);
panel.add(button);
panel.add(button2);
panel.add(button3);
return panel;
}
private static boolean push(Window owner, Window window) {
JRootPane root = getRootPane(owner);
if (root != null) {
synchronized (CACHE) {
@SuppressWarnings("unchecked")
ArrayDeque<Window> cache = (ArrayDeque<Window>) root.getClientProperty(CACHE);
if (cache == null) {
cache = new ArrayDeque<Window>();
root.putClientProperty(CACHE, cache);
}
cache.push(window);
return true;
}
}
return false;
}
protected void show0() {
JRootPane rp = null;
if (getOwner() instanceof JFrame) {
rp = ((JFrame) getOwner()).getRootPane();
} else if (getOwner() instanceof JDialog) {
rp = ((JDialog) getOwner()).getRootPane();
}
if (rp != null && !isDocumentModalitySupported() && !isExperimentalSheet()) {
ownersGlassPane = rp.getGlassPane();
JPanel blockingPanel = new JPanel();
blockingPanel.setOpaque(false);
rp.setGlassPane(blockingPanel);
blockingPanel.setVisible(true);
}
super.show();
}
protected void hide0() {
JRootPane rp = null;
if (getOwner() instanceof JFrame) {
rp = ((JFrame) getOwner()).getRootPane();
} else if (getOwner() instanceof JDialog) {
rp = ((JDialog) getOwner()).getRootPane();
}
if (rp != null && !isDocumentModalitySupported() && !isExperimentalSheet()) {
Component blockingComponent = rp.getGlassPane();
blockingComponent.setVisible(false);
if (ownersGlassPane != null) {
rp.setGlassPane(ownersGlassPane);
ownersGlassPane = null;
}
}
super.hide();
}
/**
* Invokes supers implementation of <code>installUI</code> to install the necessary state onto the
* passed in <code>JRootPane</code> to render the metal look and feel implementation of <code>
* RootPaneUI</code>. If the <code>windowDecorationStyle</code> property of the <code>JRootPane
* </code> is other than <code>JRootPane.NONE</code>, this will add a custom <code>Component
* </code> to render the widgets to <code>JRootPane</code>, as well as installing a custom <code>
* Border</code> and <code>LayoutManager</code> on the <code>JRootPane</code>.
*
* @param c the JRootPane to install state onto
*/
public void installUI(JComponent c) {
super.installUI(c);
root = (JRootPane) c;
int style = root.getWindowDecorationStyle();
if (style != JRootPane.NONE) {
installClientDecorations(root);
}
}
/**
* Returns the amount of space the layout would like to have.
*
* @param the Container for which this layout manager is being used
* @return a Dimension object containing the layout's preferred size
*/
public Dimension preferredLayoutSize(Container parent) {
Dimension cpd, tpd;
int cpWidth = 0;
int cpHeight = 0;
int mbWidth = 0;
int mbHeight = 0;
int tpWidth = 0;
Insets i = parent.getInsets();
JRootPane root = (JRootPane) parent;
if (root.getContentPane() != null) {
cpd = root.getContentPane().getPreferredSize();
} else {
cpd = root.getSize();
}
if (cpd != null) {
cpWidth = cpd.width;
cpHeight = cpd.height;
}
if (root.getWindowDecorationStyle() != JRootPane.NONE
&& (root.getUI() instanceof RootPaneUI)) {
JComponent titlePane = ((RootPaneUI) root.getUI()).getTitlePane();
if (titlePane != null) {
tpd = titlePane.getPreferredSize();
if (tpd != null) {
tpWidth = tpd.width;
}
}
}
return new Dimension(
Math.max(Math.max(cpWidth, mbWidth), tpWidth) + i.left + i.right,
cpHeight + mbHeight + tpWidth + i.top + i.bottom);
}
/** Installs the appropriate <code>Border</code> onto the <code>JRootPane</code>. */
void installBorder(JRootPane root) {
int style = root.getWindowDecorationStyle();
if (style == JRootPane.NONE) {
LookAndFeel.uninstallBorder(root);
} else {
LookAndFeel.installBorder(root, borderKeys[style]);
}
}