org.netbeans.editor.PopupManager Maven / Gradle / Ivy
/*
* Sun Public License Notice
*
* The contents of this file are subject to the Sun Public License
* Version 1.0 (the "License"). You may not use this file except in
* compliance with the License. A copy of the License is available at
* http://www.sun.com/
*
* The Original Code is NetBeans. The Initial Developer of the Original
* Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun
* Microsystems, Inc. All Rights Reserved.
*/
package org.netbeans.editor;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.Action;
import javax.swing.ActionMap;
import javax.swing.InputMap;
import javax.swing.JComponent;
import javax.swing.JLayeredPane;
import javax.swing.JRootPane;
import javax.swing.KeyStroke;
import javax.swing.text.JTextComponent;
import org.netbeans.editor.EditorUI;
import org.netbeans.editor.Utilities;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import javax.swing.SwingUtilities;
import java.awt.Component;
import javax.swing.JViewport;
import javax.swing.text.BadLocationException;
/**
* Popup manager allows to display an arbitrary popup component
* over the underlying text component.
*
* @author Martin Roskanin, Miloslav Metelka
* @since 03/2002
*/
public class PopupManager {
private JComponent popup = null;
private JTextComponent textComponent;
/** Place popup always above cursor */
public static final Placement Above = new Placement("Above"); //NOI18N
/** Place popup always below cursor */
public static final Placement Below = new Placement("Below"); //NOI18N
/** Place popup to larger area. i.e. if place below cursor is
larger than place above, then popup will be placed below cursor. */
public static final Placement Largest = new Placement("Largest"); //NOI18N
/** Place popup above cursor. If a place above cursor is insufficient,
then popup will be placed below cursor. */
public static final Placement AbovePreferred = new Placement("AbovePreferred"); //NOI18N
/** Place popup below cursor. If a place below cursor is insufficient,
then popup will be placed above cursor. */
public static final Placement BelowPreferred = new Placement("BelowPreferred"); //NOI18N
/** Place popup inside the scrollbar's viewport */
public static final HorizontalBounds ViewPortBounds = new HorizontalBounds("ViewPort"); //NOI18N
/** Place popup inside the whole scrollbar */
public static final HorizontalBounds ScrollBarBounds = new HorizontalBounds("ScrollBar"); //NOI18N
private KeyListener keyListener;
private TextComponentListener componentListener;
/** Creates a new instance of PopupManager */
public PopupManager(JTextComponent textComponent) {
this.textComponent = textComponent;
keyListener = new PopupKeyListener();
textComponent.addKeyListener(keyListener);
componentListener = new TextComponentListener();
textComponent.addComponentListener(componentListener);
}
/** Install popup component to textComponent root pane
* based on caret coordinates with the Largest placement.
* Note: Make sure the component is properly uninstalled later,
* if it is not necessary. See issue #35325 for details.
* @param popup popup component to be installed into
* root pane of the text component.
*/
public void install(JComponent popup) {
if (textComponent == null) return;
int caretPos = textComponent.getCaret().getDot();
try {
Rectangle caretBounds = textComponent.modelToView(caretPos);
install(popup, caretBounds, Largest);
} catch (BadLocationException e) {
// do not install if the caret position is invalid
}
}
/** Removes popup component from textComponent root pane
* @param popup popup component to be removed from
* root pane of the text component.
*/
public void uninstall(JComponent popup){
if (this.popup != null){
if (this.popup.isVisible()) this.popup.setVisible(false);
removeFromRootPane(this.popup);
}
if (popup!=this.popup && popup!= null){
if (popup.isVisible()) popup.setVisible(false);
removeFromRootPane(popup);
}
}
public void install(JComponent popup, Rectangle cursorBounds,
Placement placement, HorizontalBounds horizontalBounds, int horizontalAdjustment, int verticalAdjustment){
/* Uninstall the old popup from root pane
* and install the new one. Even in case
* they are the same objects it's necessary
* to cover the workspace switches etc.
*/
if (this.popup != null) {
// if i.e. completion is visible and tooltip is being installed,
// completion popup should be closed.
if (this.popup.isVisible() && this.popup!=popup) this.popup.setVisible(false);
removeFromRootPane(this.popup);
}
this.popup = popup;
if (this.popup != null) {
installToRootPane(this.popup);
}
// Update the bounds of the popup
Rectangle bounds = computeBounds(this.popup, textComponent,
cursorBounds, placement, horizontalBounds);
if (bounds != null){
// Convert to layered pane's coordinates
if (horizontalBounds == ScrollBarBounds){
bounds.x = 0;
}
JRootPane rp = textComponent.getRootPane();
if (rp!=null){
bounds = SwingUtilities.convertRectangle(textComponent, bounds,
rp.getLayeredPane());
}
if (horizontalBounds == ScrollBarBounds){
if (textComponent.getParent() instanceof JViewport){
int shift = textComponent.getParent().getX();
Rectangle viewBounds = ((JViewport)textComponent.getParent()).getViewRect();
bounds.x += viewBounds.x;
bounds.x -= shift;
bounds.width += shift;
}
}
bounds.x = bounds.x + horizontalAdjustment;
bounds.y = bounds.y + verticalAdjustment;
bounds.width = bounds.width - horizontalAdjustment;
bounds.height = bounds.height - verticalAdjustment;
this.popup.setBounds(bounds);
} else { // can't fit -> hide
this.popup.setVisible(false);
}
}
public void install(JComponent popup, Rectangle cursorBounds,
Placement placement, HorizontalBounds horizontalBounds){
install(popup, cursorBounds, placement, ViewPortBounds, 0, 0);
}
public void install(JComponent popup, Rectangle cursorBounds,
Placement placement){
install(popup, cursorBounds, placement, ViewPortBounds);
}
/** Returns installed popup panel component */
public JComponent get(){
return popup;
}
/** Install popup panel to current textComponent root pane */
private void installToRootPane(JComponent c) {
JRootPane rp = textComponent.getRootPane();
if (rp != null) {
rp.getLayeredPane().add(c, JLayeredPane.POPUP_LAYER, 0);
}
}
/** Remove popup panel from previous textComponent root pane */
private void removeFromRootPane(JComponent c) {
JRootPane rp = c.getRootPane();
if (rp != null) {
rp.getLayeredPane().remove(c);
}
}
/** Variation of the method for computing the bounds
* for the concrete view component. As the component can possibly
* be placed in a scroll pane it's first necessary
* to translate the cursor bounds and also translate
* back the resulting popup bounds.
* @param popup popup panel to be displayed
* @param view component over which the popup is displayed.
* @param cursorBounds the bounds of the caret or mouse cursor
* relative to the upper-left corner of the visible view.
* @param placement where to place the popup panel according to
* the cursor position.
* @return bounds of popup panel relative to the upper-left corner
* of the underlying view component.
* null if there is no place to display popup.
*/
protected static Rectangle computeBounds(JComponent popup,
JComponent view, Rectangle cursorBounds, Placement placement, HorizontalBounds horizontalBounds) {
if (horizontalBounds == null) horizontalBounds = ViewPortBounds;
Rectangle ret;
Component viewParent = view.getParent();
if (viewParent instanceof JViewport) {
Rectangle viewBounds = ((JViewport)viewParent).getViewRect();
Rectangle translatedCursorBounds = (Rectangle)cursorBounds.clone();
translatedCursorBounds.translate(-viewBounds.x, -viewBounds.y);
ret = computeBounds(popup, viewBounds.width, viewBounds.height,
translatedCursorBounds, placement, horizontalBounds);
if (ret != null) { // valid bounds
ret.translate(viewBounds.x, viewBounds.y);
}
} else { // not in scroll pane
ret = computeBounds(popup, view.getWidth(), view.getHeight(),
cursorBounds, placement);
}
return ret;
}
protected static Rectangle computeBounds(JComponent popup,
JComponent view, Rectangle cursorBounds, Placement placement) {
return computeBounds(popup, view, cursorBounds, placement, ViewPortBounds);
}
/** Computes a best-fit bounds of popup panel
* according to available space in the underlying view
* (visible part of the pane).
* The placement is first evaluated and put into the popup's client property
* by popup.putClientProperty(Placement.class, actual-placement).
* The actual placement is
* -
Above if the original placement was Above.
* Or if the original placement was AbovePreferred
* or Largest
* and there is more space above the cursor than below it.
* -
Below if the original placement was Below.
* Or if the original placement was BelowPreferred
* or Largest
* and there is more space below the cursor than above it.
* -
AbovePreferred if the original placement
* was AbovePreferred
* and there is less space above the cursor than below it.
* -
BelowPreferred if the original placement
* was BelowPreferred
* and there is less space below the cursor than above it.
* Once the placement client property is set
* the popup.setSize() is called with the size of the area
* above/below the cursor (indicated by the placement).
* The popup responds by updating its size to the equal or smaller
* size. If it cannot physically fit into the requested area
* it can call
* putClientProperty(Placement.class, null)
* on itself to indicate that it cannot fit. The method scans
* the content of the client property upon return from
* popup.setSize() and if it finds null there it returns
* null bounds in that case. The only exception is
* if the placement was either AbovePreferred
* or BelowPreferred. In that case the method
* gives it one more try
* by attempting to fit the popup into (bigger) complementary
* Below and Above areas (respectively).
* The popup either fits into these (bigger) areas or it again responds
* by returning null in the client property in which case
* the method finally gives up and returns null bounds.
*
* @param popup popup panel to be displayed
* @param viewWidth width of the visible view area.
* @param viewHeight height of the visible view area.
* @param cursorBounds the bounds of the caret or mouse cursor
* relative to the upper-left corner of the visible view
* @param placement where to place the popup panel according to
* the cursor position
* @return bounds of popup panel relative to the upper-left corner
* of the underlying view.
* null if there is no place to display popup.
*/
protected static Rectangle computeBounds(JComponent popup,
int viewWidth, int viewHeight, Rectangle cursorBounds, Placement placement, HorizontalBounds horizontalBounds) {
if (placement == null) {
throw new NullPointerException("placement cannot be null"); // NOI18N
}
// Compute available height above the cursor
int aboveCursorHeight = cursorBounds.y;
int belowCursorY = cursorBounds.y + cursorBounds.height;
int belowCursorHeight = viewHeight - belowCursorY;
// resolve Largest and *Preferred placements if possible
if (placement == Largest) {
placement = (aboveCursorHeight < belowCursorHeight)
? Below
: Above;
} else if (placement == AbovePreferred
&& aboveCursorHeight > belowCursorHeight // more space above
) {
placement = Above;
} else if (placement == BelowPreferred
&& belowCursorHeight > aboveCursorHeight // more space below
) {
placement = Below;
}
Rectangle popupBounds = null;
while (true) { // do one or two passes
popup.putClientProperty(Placement.class, placement);
int height = (placement == Above || placement == AbovePreferred)
? aboveCursorHeight
: belowCursorHeight;
popup.setSize(viewWidth, height);
popupBounds = popup.getBounds();
Placement updatedPlacement = (Placement)popup.getClientProperty(Placement.class);
if (updatedPlacement != placement) { // popup does not fit with the orig placement
if (placement == AbovePreferred && updatedPlacement == null) {
placement = Below;
continue;
} else if (placement == BelowPreferred && updatedPlacement == null) {
placement = Above;
continue;
}
}
if (updatedPlacement == null) {
popupBounds = null;
}
break;
}
if (popupBounds != null) {
//place popup according to caret position and Placement
popupBounds.x = Math.min(cursorBounds.x, viewWidth - popupBounds.width);
popupBounds.y = (placement == Above || placement == AbovePreferred)
? (aboveCursorHeight - popupBounds.height)
: belowCursorY;
}
return popupBounds;
}
protected static Rectangle computeBounds(JComponent popup,
int viewWidth, int viewHeight, Rectangle cursorBounds, Placement placement) {
return computeBounds(popup, viewWidth, viewHeight, cursorBounds, placement, ViewPortBounds);
}
/** Popup's key filter */
private class PopupKeyListener implements KeyListener{
public void keyTyped(KeyEvent e){}
public void keyReleased(KeyEvent e){}
public void keyPressed(KeyEvent e){
if (e == null) return;
if (popup != null && popup.isShowing()){
// get popup's registered keyboard actions
ActionMap am = popup.getActionMap();
InputMap im = popup.getInputMap();
// check whether popup registers keystroke
Object obj = im.get(KeyStroke.getKeyStrokeForEvent(e));
if (obj!=null){
// if yes, gets the popup's action for this keystroke, perform it
// and consume key event
Action action = am.get(obj);
if (action != null) {
action.actionPerformed(null);
e.consume();
}
}
}
}
}
private final class TextComponentListener extends ComponentAdapter {
public void componentHidden(ComponentEvent evt) {
install(null); // hide popup
}
}
/** Placement of popup panel specification */
public static final class Placement {
private final String representation;
private Placement(String representation) {
this.representation = representation;
}
public String toString() {
return representation;
}
}
/** Horizontal bounds of popup panel specification */
public static final class HorizontalBounds {
private final String representation;
private HorizontalBounds(String representation) {
this.representation = representation;
}
public String toString() {
return representation;
}
}
}