*
* This implementation assumes the input text and replacement text are the
* same value. It also returns the input text from its {@link #toString()}
* method (which is what
*
* Depending on the {@link CompletionProvider} installed, the following
* auto-completion features may be enabled:
*
*
*
* This implementation uses the replacement text as the input text. It also
* includes a "short description" field, which (if non-
*
* This is a convenience method for:
*
*
* By default, all completions have a relevance of
*
* Note that for this functionality to be enabled, a
* JTextComponent must be registered with the
* ToolTipManager, and the text component must know to search
* for this value. In the case of an
* RSyntaxTextArea, this
* can be done with a org.fife.ui.rtextarea.ToolTipSupplier that
* calls into
* {@link CompletionProvider#getCompletionsAt(JTextComponent, java.awt.Point)}.
*
* @return The tool tip text for this completion, or
*
* Completion providers can have an optional parent. Parents are searched for
* completions when their children are. This allows for chaining of completion
* providers.
*
* @author Robert Futrell
* @version 1.0
*/
public interface CompletionProvider {
/**
* Clears the values used to identify and insert "parameterized completions"
* (e.g. functions or methods). After this method is called, functions and
* methods will not have their parameters auto-completed.
*
* @see #setParameterizedCompletionParams(char, String, char)
*/
public void clearParameterizedCompletionParams();
/**
* Returns the text just before the current caret position that could be
* the start of something auto-completable.
*
* @param comp The text component.
* @return The text. A return value of
*
* Users should very rarely have a need to use this method.
*
* @param cl The class loader to use. If this is
*
* This method returns all characters before the caret that are matched
* by {@link #isValidChar(char)}.
*
* {@inheritDoc}
*/
public String getAlreadyEnteredText(JTextComponent comp) {
Document doc = comp.getDocument();
int dot = comp.getCaretPosition();
Element root = doc.getDefaultRootElement();
int index = root.getElementIndex(dot);
Element elem = root.getElement(index);
int start = elem.getStartOffset();
int len = dot-start;
try {
doc.getText(start, len, seg);
} catch (BadLocationException ble) {
ble.printStackTrace();
return EMPTY_STRING;
}
int segEnd = seg.offset + len;
start = segEnd - 1;
while (start>=seg.offset && isValidChar(seg.array[start])) {
start--;
}
start++;
len = segEnd - start;
return len==0 ? EMPTY_STRING : new String(seg.array, start, len);
}
/**
* {@inheritDoc}
*/
public List
*
* Alternatively, folks implementing robust code completion support for a
* language might install an
*
* This provider also implements the
* org.fife.ui.rtextarea.ToolTipSupplier interface, which allows it
* to display tooltips for completion choices. Thus the standard
* {@link VariableCompletion} and {@link FunctionCompletion} completions should
* be able to display tooltips with the variable declaration or function
* definition (provided the RSyntaxTextArea was registered with the
* javax.swing.ToolTipManager).
*
* @author Robert Futrell
* @version 1.0
*/
public class LanguageAwareCompletionProvider extends CompletionProviderBase
implements ToolTipSupplier {
/**
* The provider to use when no provider is assigned to a particular token
* type.
*/
private CompletionProvider defaultProvider;
/**
* The provider to use when completing in a string.
*/
private CompletionProvider stringCompletionProvider;
/**
* The provider to use when completing in a comment.
*/
private CompletionProvider commentCompletionProvider;
/**
* The provider to use while in documentation comments.
*/
private CompletionProvider docCommentCompletionProvider;
/**
* Constructor subclasses can use when they don't have their default
* provider created at construction time. They should call
* {@link #setDefaultCompletionProvider(CompletionProvider)} in this
* constructor.
*/
protected LanguageAwareCompletionProvider() {
}
/**
* Constructor.
*
* @param defaultProvider The provider to use when no provider is assigned
* to a particular token type. This cannot be
*
* For this method to be called, the RSyntaxTextArea must be
* registered with the javax.swing.ToolTipManager like so:
*
* DefaultListCellRenderer uses to render
* objects). Subclasses that wish to override any of this behavior can simply
* override the corresponding method(s) needed to do so.
*
* @author Robert Futrell
* @version 1.0
*/
public abstract class AbstractCompletion implements Completion {
/**
* The provider that created this completion;
*/
private CompletionProvider provider;
/**
* The relevance of this completion. Completion instances with higher
* "relevance" values are inserted higher into the list of possible
* completions than those with lower values. Completion instances with
* equal relevance values are sorted alphabetically.
*/
private int relevance;
/**
* Constructor.
*
* @param provider The provider that created this completion.
*/
public AbstractCompletion(CompletionProvider provider) {
this.provider = provider;
}
/**
* {@inheritDoc}
*/
public int compareTo(Completion c2) {
if (c2==this) {
return 0;
}
else if (c2!=null) {
return toString().compareToIgnoreCase(c2.toString());
}
return -1;
}
/**
* {@inheritDoc}
*/
public String getAlreadyEntered(JTextComponent comp) {
return provider.getAlreadyEnteredText(comp);
}
/**
* The default implementation returns null. Subclasses
* who wish to display an icon can override this method.
*
* @return The icon for this completion.
*/
public Icon getIcon() {
return null;
}
/**
* Returns the text the user has to (start) typing for this completion
* to be offered. The default implementation simply returns
* {@link #getReplacementText()}.
*
* @return The text the user has to (start) typing for this completion.
* @see #getReplacementText()
*/
public String getInputText() {
return getReplacementText();
}
/**
* {@inheritDoc}
*/
public CompletionProvider getProvider() {
return provider;
}
/**
* {@inheritDoc}
*/
public int getRelevance() {
return relevance;
}
/**
* The default implementation returns null. Subclasses
* can override this method.
*
* @return The tool tip text.
*/
public String getToolTipText() {
return null;
}
/**
* Sets the relevance of this completion.
*
* @param relevance The new relevance of this completion.
* @see #getRelevance()
*/
public void setRelevance(int relevance) {
this.relevance = relevance;
}
/**
* Returns a string representation of this completion. The default
* implementation returns {@link #getInputText()}.
*
* @return A string representation of this completion.
*/
@Override
public String toString() {
return getInputText();
}
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/AbstractCompletionProvider.java 0000664 0000000 0000000 00000015073 12207001023 0027770 0 ustar 00root root 0000000 0000000 /*
* 12/21/2008
*
* AbstractCompletionProvider.java - Base class for completion providers.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.swing.text.JTextComponent;
/**
* A base class for completion providers. {@link Completion}s are kept in
* a sorted list. To get the list of completions that match a given input,
* a binary search is done to find the first matching completion, then all
* succeeding completions that also match are also returned.
*
* @author Robert Futrell
* @version 1.0
*/
public abstract class AbstractCompletionProvider
extends CompletionProviderBase {
/**
* The completions this provider is aware of. Subclasses should ensure
* that this list is sorted alphabetically (case-insensitively).
*/
protected Listnull.
* @throws IllegalArgumentException If a completion's provider isn't
* this CompletionProvider.
* @see #addCompletion(Completion)
* @see #removeCompletion(Completion)
* @see #clear()
*/
public void addCompletions(Listnull if there
* are no matching Completions.
*/
@SuppressWarnings("unchecked")
public ListExternalURLHandlers.
*
* @param completion The completion to display.
* @param anchor The anchor in the HTML to jump to, or null
* if none.
*/
public void showSummaryFor(Completion completion, String anchor) {
setDescriptionFor(completion, anchor, true);
}
/**
* Called by the parent completion popup window the LookAndFeel is updated.
*/
public void updateUI() {
SwingUtilities.updateComponentTreeUI(this);
// Update editor pane for new font, bg, selection colors, etc.
TipUtil.tweakTipEditorPane(descArea);
scrollPane.setBackground(descArea.getBackground());
scrollPane.getViewport().setBackground(descArea.getBackground());
((JPanel)getContentPane()).setBorder(TipUtil.getToolTipBorder());
}
/**
* A completion and its cached summary text.
*/
private static class HistoryEntry {
public Completion completion;
public String summary;
public String anchor;
public HistoryEntry(Completion completion, String summary,
String anchor) {
this.completion = completion;
this.summary = summary;
this.anchor = anchor;
}
/**
* Overridden to display a short name for the completion, since it's
* used in the tool tips for the "back" and "forward" buttons.
*
* @return A string representation of this history entry.
*/
@Override
public String toString() {
return completion.getInputText();
}
}
/**
* Action that actually updates the summary text displayed.
*/
private class TimerAction extends AbstractAction {
private Completion completion;
private String anchor;
private boolean addToHistory;
/**
* Called when the timer is fired.
*/
public void actionPerformed(ActionEvent e) {
setDisplayedDesc(completion, anchor, addToHistory);
}
public void setCompletion(Completion c, String anchor,
boolean addToHistory) {
this.completion = c;
this.anchor = anchor;
this.addToHistory = addToHistory;
}
}
/**
* Action that moves to the previous description displayed.
*/
class ToolBarBackAction extends AbstractAction {
public ToolBarBackAction(boolean ltr) {
String img = "org/fife/ui/autocomplete/arrow_" +
(ltr ? "left.png" : "right.png");
ClassLoader cl = getClass().getClassLoader();
Icon icon = new ImageIcon(cl.getResource(img));
putValue(Action.SMALL_ICON, icon);
}
public void actionPerformed(ActionEvent e) {
if (historyPos>0) {
HistoryEntry pair = history.get(--historyPos);
descArea.setText(pair.summary);
if (pair.anchor!=null) {
//System.out.println("Scrolling to: " + pair.anchor);
descArea.scrollToReference(pair.anchor);
}
else {
descArea.setCaretPosition(0);
}
setActionStates();
}
}
}
/**
* Action that moves to the previous description displayed.
*/
class ToolBarForwardAction extends AbstractAction {
public ToolBarForwardAction(boolean ltr) {
String img = "org/fife/ui/autocomplete/arrow_" +
(ltr ? "right.png" : "left.png");
ClassLoader cl = getClass().getClassLoader();
Icon icon = new ImageIcon(cl.getResource(img));
putValue(Action.SMALL_ICON, icon);
}
public void actionPerformed(ActionEvent e) {
if (history!=null && historyPosnull.
*/
public void setDescriptionWindowSize(Dimension size) {
if (descWindow!=null) {
descWindow.setSize(size);
}
else {
preferredDescWindowSize = size;
}
}
/**
* Sets the default list cell renderer to use when a completion provider
* does not supply its own.
*
* @param renderer The renderer to use. If this is null,
* a default renderer is used.
* @see #getListCellRenderer()
*/
public void setListCellRenderer(ListCellRenderer renderer) {
DelegatingCellRenderer dcr = (DelegatingCellRenderer)list.
getCellRenderer();
dcr.setFallbackCellRenderer(renderer);
}
/**
* Sets the location of this window to be "good" relative to the specified
* rectangle. That rectangle should be the location of the text
* component's caret, in screen coordinates.
*
* @param r The text component's caret position, in screen coordinates.
*/
public void setLocationRelativeTo(Rectangle r) {
// Multi-monitor support - make sure the completion window (and
// description window, if applicable) both fit in the same window in
// a multi-monitor environment. To do this, we decide which monitor
// the rectangle "r" is in, and use that one (just pick top-left corner
// as the defining point).
Rectangle screenBounds = Util.getScreenBoundsForPoint(r.x, r.y);
//Dimension screenSize = getToolkit().getScreenSize();
boolean showDescWindow = descWindow!=null && ac.getShowDescWindow();
int totalH = getHeight();
if (showDescWindow) {
totalH = Math.max(totalH, descWindow.getHeight());
}
// Try putting our stuff "below" the caret first. We assume that the
// entire height of our stuff fits on the screen one way or the other.
aboveCaret = false;
int y = r.y + r.height + VERTICAL_SPACE;
if (y+totalH>screenBounds.height) {
y = r.y - VERTICAL_SPACE - getHeight();
aboveCaret = true;
}
// Get x-coordinate of completions. Try to align left edge with the
// caret first.
int x = r.x;
if (!ac.getTextComponentOrientation().isLeftToRight()) {
x -= getWidth(); // RTL => align right edge
}
if (x
*
*
* @author Robert Futrell
* @version 1.0
*/
/*
* This class handles intercepting window and hierarchy events from the text
* component, so the popup window is only visible when it should be visible.
* It also handles communication between the CompletionProvider and the actual
* popup Window.
*/
public class AutoCompletion {
/**
* The text component we're providing completion for.
*/
private JTextComponent textComponent;
/**
* The parent window of {@link #textComponent}.
*/
private Window parentWindow;
/**
* The popup window containing completion choices.
*/
private AutoCompletePopupWindow popupWindow;
/**
* The preferred size of the completion choices window. This field exists
* because the user will likely set the preferred size of the window
* before it is actually created.
*/
private Dimension preferredChoicesWindowSize;
/**
* The preferred size of the optional description window. This field
* only exists because the user may (and usually will) set the size of
* the description window before it exists (it must be parented to a
* Window).
*/
private Dimension preferredDescWindowSize;
/**
* Manages any parameterized completions that are inserted.
*/
private ParameterizedCompletionContext pcc;
/**
* Provides the completion options relevant to the current caret position.
*/
private CompletionProvider provider;
/**
* The renderer to use for the completion choices. If this is
* null, then a default renderer is used.
*/
private ListCellRenderer renderer;
/**
* The handler to use when an external URL is clicked in the help
* documentation.
*/
private ExternalURLHandler externalURLHandler;
/**
* An optional redirector that converts URL's to some other location before
* being handed over to externalURLHandler.
*/
private static LinkRedirector linkRedirector;
/**
* Whether the description window should be displayed along with the
* completion choice window.
*/
private boolean showDescWindow;
/**
* Whether auto-complete is enabled.
*/
private boolean autoCompleteEnabled;
/**
* Whether the auto-activation of auto-complete (after a delay, after the
* user types an appropriate character) is enabled.
*/
private boolean autoActivationEnabled;
/**
* Whether or not, when there is only a single auto-complete option
* that matches the text at the current text position, that text should
* be auto-inserted, instead of the completion window displaying.
*/
private boolean autoCompleteSingleChoices;
/**
* Whether parameter assistance is enabled.
*/
private boolean parameterAssistanceEnabled;
/**
* A renderer used for {@link Completion}s in the optional parameter
* choices popup window (displayed when a {@link ParameterizedCompletion}
* is code-completed). If this isn't set, a default renderer is used.
*/
private ListCellRenderer paramChoicesRenderer;
/**
* The keystroke that triggers the completion window.
*/
private KeyStroke trigger;
/**
* The previous key in the text component's InputMap for the
* trigger key.
*/
private Object oldTriggerKey;
/**
* The action previously assigned to {@link #trigger}, so we can reset it
* if the user disables auto-completion.
*/
private Action oldTriggerAction;
/**
* The previous key in the text component's InputMap for the
* parameter completion trigger key.
*/
private Object oldParenKey;
/**
* The action previously assigned to the parameter completion key, so we
* can reset it when we uninstall.
*/
private Action oldParenAction;
/**
* Listens for events in the parent window that affect the visibility of
* the popup windows.
*/
private ParentWindowListener parentWindowListener;
/**
* Listens for events from the text component that affect the visibility
* of the popup windows.
*/
private TextComponentListener textComponentListener;
/**
* Listens for events in the text component that cause the popup windows
* to automatically activate.
*/
private AutoActivationListener autoActivationListener;
/**
* Listens for LAF changes so the auto-complete windows automatically
* update themselves accordingly.
*/
private LookAndFeelChangeListener lafListener;
/**
* The key used in the input map for the AutoComplete action.
*/
private static final String PARAM_TRIGGER_KEY = "AutoComplete";
/**
* Key used in the input map for the parameter completion action.
*/
private static final String PARAM_COMPLETE_KEY = "AutoCompletion.FunctionStart";
/**
* Stores how to render auto-completion-specific highlights in text
* components.
*/
private static final AutoCompletionStyleContext styleContext =
new AutoCompletionStyleContext();
/**
* Whether debug messages should be printed to stdout as AutoCompletion
* runs.
*/
private static final boolean DEBUG = initDebug();
/**
* Constructor.
*
* @param provider The completion provider. This cannot be
* null.
*/
public AutoCompletion(CompletionProvider provider) {
setChoicesWindowSize(350, 200);
setDescriptionWindowSize(350, 250);
setCompletionProvider(provider);
setTriggerKey(getDefaultTriggerKey());
setAutoCompleteEnabled(true);
setAutoCompleteSingleChoices(true);
setAutoActivationEnabled(false);
setShowDescWindow(false);
parentWindowListener = new ParentWindowListener();
textComponentListener = new TextComponentListener();
autoActivationListener = new AutoActivationListener();
lafListener = new LookAndFeelChangeListener();
}
/**
* Displays the popup window. Hosting applications can call this method
* to programmatically begin an auto-completion operation.
*/
public void doCompletion() {
refreshPopupWindow();
}
/**
* Returns the delay between when the user types a character and when the
* code completion popup should automatically appear (if applicable).
*
* @return The delay, in milliseconds.
* @see #setAutoActivationDelay(int)
*/
public int getAutoActivationDelay() {
return autoActivationListener.timer.getDelay();
}
/**
* Returns whether, if a single auto-complete choice is available, it
* should be automatically inserted, without displaying the popup menu.
*
* @return Whether to auto-complete single choices.
* @see #setAutoCompleteSingleChoices(boolean)
*/
public boolean getAutoCompleteSingleChoices() {
return autoCompleteSingleChoices;
}
/**
* Returns the completion provider.
*
* @return The completion provider.
*/
public CompletionProvider getCompletionProvider() {
return provider;
}
/**
* Returns whether debug is enabled for AutoCompletion.
*
* @return Whether debug is enabled.
*/
static boolean getDebug() {
return DEBUG;
}
/**
* Returns the default auto-complete "trigger key" for this OS. For
* Windows, for example, it is Ctrl+Space.
*
* @return The default auto-complete trigger key.
*/
public static KeyStroke getDefaultTriggerKey() {
// Default to CTRL, even on Mac, since Ctrl+Space activates Spotlight
int mask = InputEvent.CTRL_MASK;
return KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, mask);
}
/**
* Returns the handler to use when an external URL is clicked in the
* description window.
*
* @return The handler.
* @see #setExternalURLHandler(ExternalURLHandler)
* @see #getLinkRedirector()
*/
public ExternalURLHandler getExternalURLHandler() {
return externalURLHandler;
}
int getLineOfCaret() {
Document doc = textComponent.getDocument();
Element root = doc.getDefaultRootElement();
return root.getElementIndex(textComponent.getCaretPosition());
}
/**
* Returns the link redirector, if any.
*
* @return The link redirector, or null if none.
* @see #setLinkRedirector(LinkRedirector)
*/
public static LinkRedirector getLinkRedirector() {
return linkRedirector;
}
/**
* Returns the default list cell renderer used when a completion provider
* does not supply its own.
*
* @return The default list cell renderer.
* @see #setListCellRenderer(ListCellRenderer)
*/
public ListCellRenderer getListCellRenderer() {
return renderer;
}
/**
* Returns the renderer to use for {@link Completion}s in the optional
* parameter choices popup window (displayed when a
* {@link ParameterizedCompletion} is code-completed). If this returns
* null, a default renderer is used.
*
* @return The renderer to use.
* @see #setParamChoicesRenderer(ListCellRenderer)
* @see #isParameterAssistanceEnabled()
*/
public ListCellRenderer getParamChoicesRenderer() {
return paramChoicesRenderer;
}
/**
* Returns the text to replace with in the document. This is a
* "last-chance" hook for subclasses to make special modifications to the
* completion text inserted. The default implementation simply returns
* c.getReplacementText(). You usually will not need to modify
* this method.
*
* @param c The completion being inserted.
* @param doc The document being modified.
* @param start The start of the text being replaced.
* @param len The length of the text being replaced.
* @return The text to replace with.
*/
protected String getReplacementText(Completion c, Document doc, int start,
int len) {
return c.getReplacementText();
}
/**
* Returns whether the "description window" should be shown alongside
* the completion window.
*
* @return Whether the description window should be shown.
* @see #setShowDescWindow(boolean)
*/
public boolean getShowDescWindow() {
return showDescWindow;
}
/**
* Returns the style context describing how auto-completion related
* highlights in the editor are rendered.
*
* @return The style context.
*/
public static AutoCompletionStyleContext getStyleContext() {
return styleContext;
}
/**
* Returns the text component for which auto-completion is enabled.
*
* @return The text component, or null if this
* {@link AutoCompletion} is not installed on any text component.
* @see #install(JTextComponent)
*/
public JTextComponent getTextComponent() {
return textComponent;
}
/**
* Returns the orientation of the text component we're installed to.
*
* @return The orientation of the text component, or null if
* we are not installed on one.
*/
ComponentOrientation getTextComponentOrientation() {
return textComponent==null ? null :
textComponent.getComponentOrientation();
}
/**
* Returns the "trigger key" used for auto-complete.
*
* @return The trigger key.
* @see #setTriggerKey(KeyStroke)
*/
public KeyStroke getTriggerKey() {
return trigger;
}
/**
* Hides any child windows being displayed by the auto-completion system.
*
* @return Whether any windows were visible.
*/
public boolean hideChildWindows() {
//return hidePopupWindow() || hideToolTipWindow();
boolean res = hidePopupWindow();
res |= hideParameterCompletionPopups();
return res;
}
/**
* Hides and disposes of any parameter completion-related popups.
*
* @return Whether any such windows were visible (and thus hidden).
*/
private boolean hideParameterCompletionPopups() {
if (pcc!=null) {
pcc.deactivate();
pcc = null;
return true;
}
return false;
}
/**
* Hides the popup window, if it is visible.
*
* @return Whether the popup window was visible.
*/
private boolean hidePopupWindow() {
if (popupWindow!=null) {
if (popupWindow.isVisible()) {
popupWindow.setVisible(false);
return true;
}
}
return false;
}
/**
* Determines whether debug should be enabled for the AutoCompletion
* library. This method checks a system property, but takes care of
* {@link SecurityException}s in case we're in an applet or WebStart.
*
* @return Whether debug should be enabled.
*/
private static final boolean initDebug() {
boolean debug = false;
try {
debug = Boolean.getBoolean("AutoCompletion.debug");
} catch (SecurityException se) { // We're in an applet or WebStart.
debug = false;
}
return debug;
}
/**
* Inserts a completion. Any time a code completion event occurs, the
* actual text insertion happens through this method.
*
* @param c A completion to insert. This cannot be null.
*/
protected final void insertCompletion(Completion c) {
insertCompletion(c, false);
}
/**
* Inserts a completion. Any time a code completion event occurs, the
* actual text insertion happens through this method.
*
* @param c A completion to insert. This cannot be null.
* @param typedParamListStartChar Whether the parameterized completion
* start character was typed (typically '(').
*/
protected void insertCompletion(Completion c,
boolean typedParamListStartChar) {
JTextComponent textComp = getTextComponent();
String alreadyEntered = c.getAlreadyEntered(textComp);
hidePopupWindow();
Caret caret = textComp.getCaret();
int dot = caret.getDot();
int len = alreadyEntered.length();
int start = dot-len;
String replacement = getReplacementText(c, textComp.getDocument(),
start, len);
caret.setDot(start);
caret.moveDot(dot);
textComp.replaceSelection(replacement);
if (isParameterAssistanceEnabled() &&
(c instanceof ParameterizedCompletion)) {
ParameterizedCompletion pc = (ParameterizedCompletion)c;
startParameterizedCompletionAssistance(pc, typedParamListStartChar);
}
}
/**
* Installs this auto-completion on a text component. If this
* {@link AutoCompletion} is already installed on another text component,
* it is uninstalled first.
*
* @param c The text component.
* @see #uninstall()
*/
public void install(JTextComponent c) {
if (textComponent!=null) {
uninstall();
}
this.textComponent = c;
installTriggerKey(getTriggerKey());
// Install the function completion key, if there is one.
// NOTE: We cannot do this if the start char is ' ' (e.g. just a space
// between the function name and parameters) because it overrides
// RSTA's special space action. It seems KeyStorke.getKeyStroke(' ')
// hoses ctrl+space, shift+space, etc., even though I think it
// shouldn't...
char start = provider.getParameterListStart();
if (start!=0 && start!=' ') {
InputMap im = c.getInputMap();
ActionMap am = c.getActionMap();
KeyStroke ks = KeyStroke.getKeyStroke(start);
oldParenKey = im.get(ks);
im.put(ks, PARAM_COMPLETE_KEY);
oldParenAction = am.get(PARAM_COMPLETE_KEY);
am.put(PARAM_COMPLETE_KEY,
new ParameterizedCompletionStartAction(start));
}
textComponentListener.addTo(this.textComponent);
// In case textComponent is already in a window...
textComponentListener.hierarchyChanged(null);
if (isAutoActivationEnabled()) {
autoActivationListener.addTo(this.textComponent);
}
UIManager.addPropertyChangeListener(lafListener);
updateUI(); // In case there have been changes since we uninstalled
}
/**
* Installs a "trigger key" action onto the current text component.
*
* @param ks The keystroke that should trigger the action.
* @see #uninstallTriggerKey()
*/
private void installTriggerKey(KeyStroke ks) {
InputMap im = textComponent.getInputMap();
oldTriggerKey = im.get(ks);
im.put(ks, PARAM_TRIGGER_KEY);
ActionMap am = textComponent.getActionMap();
oldTriggerAction = am.get(PARAM_TRIGGER_KEY);
am.put(PARAM_TRIGGER_KEY, new AutoCompleteAction());
}
/**
* Returns whether auto-activation is enabled (that is, whether the
* completion popup will automatically appear after a delay when the user
* types an appropriate character). Note that this parameter will be
* ignored if auto-completion is disabled.
*
* @return Whether auto-activation is enabled.
* @see #setAutoActivationEnabled(boolean)
* @see #getAutoActivationDelay()
* @see #isAutoCompleteEnabled()
*/
public boolean isAutoActivationEnabled() {
return autoActivationEnabled;
}
/**
* Returns whether auto-completion is enabled.
*
* @return Whether auto-completion is enabled.
* @see #setAutoCompleteEnabled(boolean)
*/
public boolean isAutoCompleteEnabled() {
return autoCompleteEnabled;
}
/**
* Returns whether parameter assistance is enabled.
*
* @return Whether parameter assistance is enabled.
* @see #setParameterAssistanceEnabled(boolean)
*/
public boolean isParameterAssistanceEnabled() {
return parameterAssistanceEnabled;
}
/**
* Returns whether the popup window is visible.
*
* @return Whether the popup window is visible.
*/
private boolean isPopupVisible() {
return popupWindow!=null && popupWindow.isVisible();
}
/**
* Refreshes the popup window. First, this method gets the possible
* completions for the current caret position. If there are none, and the
* popup is visible, it is hidden. If there are some completions and the
* popup is hidden, it is made visible and made to display the completions.
* If there are some completions and the popup is visible, its list is
* updated to the current set of completions.
*
* @return The current line number of the caret.
*/
protected int refreshPopupWindow() {
// A return value of null => don't suggest completions
String text = provider.getAlreadyEnteredText(textComponent);
if (text==null && !isPopupVisible()) {
return getLineOfCaret();
}
// If the popup is currently visible, and they type a space (or any
// character that resets the completion list to "all completions"),
// the popup window should be hidden instead of being reset to show
// everything.
int textLen = text==null ? 0 : text.length();
if (textLen==0) {
if (isPopupVisible()) {
hidePopupWindow();
return getLineOfCaret();
}
}
final Listnull.
* @throws IllegalArgumentException If provider is
* null.
*/
public void setCompletionProvider(CompletionProvider provider) {
if (provider==null) {
throw new IllegalArgumentException("provider cannot be null");
}
this.provider = provider;
hidePopupWindow(); // In case new choices should be displayed.
}
/**
* Sets the size of the completion choices window.
*
* @param w The new width.
* @param h The new height.
* @see #setDescriptionWindowSize(int, int)
*/
public void setChoicesWindowSize(int w, int h) {
preferredChoicesWindowSize = new Dimension(w, h);
if (popupWindow!=null) {
popupWindow.setSize(preferredChoicesWindowSize);
}
}
/**
* Sets the size of the description window.
*
* @param w The new width.
* @param h The new height.
* @see #setChoicesWindowSize(int, int)
*/
public void setDescriptionWindowSize(int w, int h) {
preferredDescWindowSize = new Dimension(w, h);
if (popupWindow!=null) {
popupWindow.setDescriptionWindowSize(preferredDescWindowSize);
}
}
/**
* Sets the handler to use when an external URL is clicked in the
* description window. This handler can perform some action, such as
* open the URL in a web browser. The default implementation will open
* the URL in a browser, but only if running in Java 6. If you want
* browser support for Java 5 and below, or otherwise want to respond to
* hyperlink clicks, you will have to install your own handler to do so.
*
* @param handler The new handler.
* @see #getExternalURLHandler()
*/
public void setExternalURLHandler(ExternalURLHandler handler) {
this.externalURLHandler = handler;
}
/**
* Sets the redirector for external URL's found in code completion
* documentation. When a non-local link in completion popups is clicked,
* this redirector is given the chance to modify the URL fetched and
* displayed.
*
* @param linkRedirector The link redirector, or null for
* none.
* @see #getLinkRedirector()
*/
public static void setLinkRedirector(LinkRedirector linkRedirector) {
AutoCompletion.linkRedirector = linkRedirector;
}
/**
* Sets the default list cell renderer to use when a completion provider
* does not supply its own.
*
* @param renderer The renderer to use. If this is null,
* a default renderer is used.
* @see #getListCellRenderer()
*/
public void setListCellRenderer(ListCellRenderer renderer) {
this.renderer = renderer;
if (popupWindow!=null) {
popupWindow.setListCellRenderer(renderer);
hidePopupWindow();
}
}
/**
* Sets the renderer to use for {@link Completion}s in the optional
* parameter choices popup window (displayed when a
* {@link ParameterizedCompletion} is code-completed). If this isn't set,
* a default renderer is used.
*
* @param r The renderer to use.
* @see #getParamChoicesRenderer()
* @see #setParameterAssistanceEnabled(boolean)
*/
public void setParamChoicesRenderer(ListCellRenderer r) {
paramChoicesRenderer = r;
}
/**
* Sets whether parameter assistance is enabled. If parameter assistance
* is enabled, and a "parameterized" completion (such as a function or
* method) is inserted, the user will get "assistance" in inserting the
* parameters in the form of a popup window with documentation and easy
* tabbing through the arguments (as seen in Eclipse and NetBeans).
*
* @param enabled Whether parameter assistance should be enabled.
* @see #isParameterAssistanceEnabled()
*/
public void setParameterAssistanceEnabled(boolean enabled) {
parameterAssistanceEnabled = enabled;
}
/**
* Sets whether the "description window" should be shown beside the
* completion window.
*
* @param show Whether to show the description window.
* @see #getShowDescWindow()
*/
public void setShowDescWindow(boolean show) {
hidePopupWindow(); // Needed to force it to take effect
showDescWindow = show;
}
/**
* Sets the keystroke that should be used to trigger the auto-complete
* popup window.
*
* @param ks The keystroke.
* @throws IllegalArgumentException If ks is null.
* @see #getTriggerKey()
*/
public void setTriggerKey(KeyStroke ks) {
if (ks==null) {
throw new IllegalArgumentException("trigger key cannot be null");
}
if (!ks.equals(trigger)) {
if (textComponent!=null) {
// Put old trigger action back.
uninstallTriggerKey();
// Grab current action for new trigger and replace it.
installTriggerKey(ks);
}
trigger = ks;
}
}
/**
* Displays a "tool tip" detailing the inputs to the function just entered.
*
* @param pc The completion.
* @param typedParamListStartChar Whether the parameterized completion list
* starting character was typed.
*/
private void startParameterizedCompletionAssistance(
ParameterizedCompletion pc, boolean typedParamListStartChar) {
// Get rid of the previous tool tip window, if there is one.
hideParameterCompletionPopups();
// Don't bother with a tool tip if there are no parameters, but if
// they typed e.g. the opening '(', make them overtype the ')'.
if (pc.getParamCount()==0 && !(pc instanceof TemplateCompletion)) {
CompletionProvider p = pc.getProvider();
char end = p.getParameterListEnd(); // Might be '\0'
String text = end=='\0' ? "" : Character.toString(end);
if (typedParamListStartChar) {
String template = "${}" + text + "${cursor}";
textComponent.replaceSelection(Character.toString(p.getParameterListStart()));
TemplateCompletion tc = new TemplateCompletion(p, null, null, template);
pc = tc;
}
else {
text = p.getParameterListStart() + text;
textComponent.replaceSelection(text);
return;
}
}
pcc = new ParameterizedCompletionContext(parentWindow, this, pc);
pcc.activate();
}
/**
* Uninstalls this auto-completion from its text component. If it is not
* installed on any text component, nothing happens.
*
* @see #install(JTextComponent)
*/
public void uninstall() {
if (textComponent!=null) {
hidePopupWindow(); // Unregisters listeners, actions, etc.
uninstallTriggerKey();
// Uninstall the function completion key.
char start = provider.getParameterListStart();
if (start!=0) {
KeyStroke ks = KeyStroke.getKeyStroke(start);
InputMap im = textComponent.getInputMap();
im.put(ks, oldParenKey);
ActionMap am = textComponent.getActionMap();
am.put(PARAM_COMPLETE_KEY, oldParenAction);
}
textComponentListener.removeFrom(textComponent);
if (parentWindow!=null) {
parentWindowListener.removeFrom(parentWindow);
}
if (isAutoActivationEnabled()) {
autoActivationListener.removeFrom(textComponent);
}
UIManager.removePropertyChangeListener(lafListener);
textComponent = null;
popupWindow = null;
}
}
/**
* Replaces the "trigger key" action with the one that was there
* before auto-completion was installed.
*
* @see #installTriggerKey(KeyStroke)
*/
private void uninstallTriggerKey() {
InputMap im = textComponent.getInputMap();
im.put(trigger, oldTriggerKey);
ActionMap am = textComponent.getActionMap();
am.put(PARAM_TRIGGER_KEY, oldTriggerAction);
}
/**
* Updates the LookAndFeel of the popup window. Applications can call
* this method as appropriate if they support changing the LookAndFeel
* at runtime.
*/
private void updateUI() {
if (popupWindow!=null) {
popupWindow.updateUI();
}
if (pcc!=null) {
pcc.updateUI();
}
// Will practically always be a JComponent (a JLabel)
if (paramChoicesRenderer instanceof JComponent) {
((JComponent)paramChoicesRenderer).updateUI();
}
}
/**
* Listens for events in the text component to auto-activate the code
* completion popup.
*/
private class AutoActivationListener extends FocusAdapter
implements DocumentListener, CaretListener, ActionListener {
private Timer timer;
private boolean justInserted;
public AutoActivationListener() {
timer = new Timer(200, this);
timer.setRepeats(false);
}
public void actionPerformed(ActionEvent e) {
doCompletion();
}
public void addTo(JTextComponent tc) {
tc.addFocusListener(this);
tc.getDocument().addDocumentListener(this);
tc.addCaretListener(this);
}
public void caretUpdate(CaretEvent e) {
if (justInserted) {
justInserted = false;
}
else {
timer.stop();
}
}
public void changedUpdate(DocumentEvent e) {
// Ignore
}
@Override
public void focusLost(FocusEvent e) {
timer.stop();
//hideChildWindows(); Other listener will do this
}
public void insertUpdate(DocumentEvent e) {
justInserted = false;
if (isAutoCompleteEnabled() && isAutoActivationEnabled() &&
e.getLength()==1) {
if (provider.isAutoActivateOkay(textComponent)) {
timer.restart();
justInserted = true;
}
else {
timer.stop();
}
}
else {
timer.stop();
}
}
public void removeFrom(JTextComponent tc) {
tc.removeFocusListener(this);
tc.getDocument().removeDocumentListener(this);
tc.removeCaretListener(this);
timer.stop();
justInserted = false;
}
public void removeUpdate(DocumentEvent e) {
timer.stop();
}
}
/**
* The Action that displays the popup window if
* auto-completion is enabled.
*/
private class AutoCompleteAction extends AbstractAction {
public void actionPerformed(ActionEvent e) {
if (isAutoCompleteEnabled()) {
refreshPopupWindow();
}
else if (oldTriggerAction!=null) {
oldTriggerAction.actionPerformed(e);
}
}
}
/**
* Listens for LookAndFeel changes and updates the various popup windows
* involved in auto-completion accordingly.
*/
private class LookAndFeelChangeListener implements PropertyChangeListener {
public void propertyChange(PropertyChangeEvent e) {
String name = e.getPropertyName();
if ("lookAndFeel".equals(name)) {
updateUI();
}
}
}
/**
* Action that starts a parameterized completion, e.g. after '(' is
* typed.
*/
private class ParameterizedCompletionStartAction extends AbstractAction {
private String start;
public ParameterizedCompletionStartAction(char ch) {
this.start = Character.toString(ch);
}
public void actionPerformed(ActionEvent e) {
// Prevents keystrokes from messing up
boolean wasVisible = hidePopupWindow();
// Only proceed if they were selecting a completion
if (!wasVisible || !isParameterAssistanceEnabled()) {
textComponent.replaceSelection(start);
return;
}
Completion c = popupWindow.getSelection();
if (c instanceof ParameterizedCompletion) { // Should always be true
// Fixes capitalization of the entered text.
insertCompletion(c, true);
}
}
}
/**
* Listens for events in the parent window of the text component with
* auto-completion enabled.
*/
private class ParentWindowListener extends ComponentAdapter
implements WindowFocusListener {
public void addTo(Window w) {
w.addComponentListener(this);
w.addWindowFocusListener(this);
}
@Override
public void componentHidden(ComponentEvent e) {
hideChildWindows();
}
@Override
public void componentMoved(ComponentEvent e) {
hideChildWindows();
}
@Override
public void componentResized(ComponentEvent e) {
hideChildWindows();
}
public void removeFrom(Window w) {
w.removeComponentListener(this);
w.removeWindowFocusListener(this);
}
public void windowGainedFocus(WindowEvent e) {
}
public void windowLostFocus(WindowEvent e) {
hideChildWindows();
}
}
/**
* Listens for events from the text component we're installed on.
*/
private class TextComponentListener extends FocusAdapter
implements HierarchyListener {
void addTo(JTextComponent tc) {
tc.addFocusListener(this);
tc.addHierarchyListener(this);
}
/**
* Hide the auto-completion windows when the text component loses
* focus.
*/
@Override
public void focusLost(FocusEvent e) {
hideChildWindows();
}
/**
* Called when the component hierarchy for our text component changes.
* When the text component is added to a new {@link Window}, this
* method registers listeners on that Window.
*
* @param e The event.
*/
public void hierarchyChanged(HierarchyEvent e) {
// NOTE: e many be null as we call this method at other times.
//System.out.println("Hierarchy changed! " + e);
Window oldParentWindow = parentWindow;
parentWindow = SwingUtilities.getWindowAncestor(textComponent);
if (parentWindow!=oldParentWindow) {
if (oldParentWindow!=null) {
parentWindowListener.removeFrom(oldParentWindow);
}
if (parentWindow!=null) {
parentWindowListener.addTo(parentWindow);
}
}
}
public void removeFrom(JTextComponent tc) {
tc.removeFocusListener(this);
tc.removeHierarchyListener(this);
}
}
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/AutoCompletionStyleContext.java 0000664 0000000 0000000 00000005714 12207001023 0030011 0 ustar 00root root 0000000 0000000 /*
* 06/24/2012
*
* AutoCompletionStyleContext.java - Manages styles related to auto-completion.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import java.awt.Color;
/**
* Manages the colors shared across the library.
*
* @author Robert Futrell
* @version 1.0
*/
public class AutoCompletionStyleContext {
/**
* The color used to denote the ending caret position for parameterized
* completions.
*/
private Color parameterizedCompletionCursorPositionColor;
/**
* The color used to highlight copies of editable parameters in
* parameterized completions.
*/
private Color parameterCopyColor;
/**
* The color of the outline highlight used to denote editable parameters
* in parameterized completions.
*/
private Color parameterOutlineColor;
public AutoCompletionStyleContext() {
setParameterOutlineColor(Color.gray);
setParameterCopyColor(new Color(0xb4d7ff));
setParameterizedCompletionCursorPositionColor(new Color(0x00b400));
}
/**
* Returns the color of the highlight painted on copies of editable
* parameters in parameterized completions.
*
* @return The color used.
* @see #setParameterCopyColor(Color)
*/
public Color getParameterCopyColor() {
return parameterCopyColor;
}
/**
* Returns the color used to denote the ending caret position for
* parameterized completions.
*
* @return The color used.
* @see #setParameterizedCompletionCursorPositionColor(Color)
*/
public Color getParameterizedCompletionCursorPositionColor() {
return parameterizedCompletionCursorPositionColor;
}
/**
* Returns the color of the outline highlight used to denote editable
* parameters in parameterized completions.
*
* @return The color used.
* @see #setParameterOutlineColor(Color)
*/
public Color getParameterOutlineColor() {
return parameterOutlineColor;
}
/**
* Sets the color of the highlight painted on copies of editable
* parameters in parameterized completions.
*
* @param color The color to use.
* @see #setParameterCopyColor(Color)
*/
public void setParameterCopyColor(Color color) {
this.parameterCopyColor = color;
}
/**
* Sets the color used to denote the ending caret position for
* parameterized completions.
*
* @param color The color to use.
* @see #getParameterizedCompletionCursorPositionColor()
*/
public void setParameterizedCompletionCursorPositionColor(Color color) {
this.parameterizedCompletionCursorPositionColor = color;
}
/**
* Sets the color of the outline highlight used to denote editable
* parameters in parameterized completions.
*
* @param color The color to use.
* @see #getParameterOutlineColor()
*/
public void setParameterOutlineColor(Color color) {
this.parameterOutlineColor = color;
}
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/BasicCompletion.java 0000664 0000000 0000000 00000007211 12207001023 0025526 0 ustar 00root root 0000000 0000000 /*
* 01/03/2009
*
* BasicCompletion.java - A straightforward Completion implementation.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
/**
* A straightforward {@link Completion} implementation. This implementation
* can be used if you have a relatively short number of static completions
* with no (or short) summaries.null), is
* used in the completion choices list.
*
* @author Robert Futrell
* @version 1.0
*/
public class BasicCompletion extends AbstractCompletion {
private String replacementText;
private String shortDesc;
private String summary;
/**
* Constructor.
*
* @param provider The parent completion provider.
* @param replacementText The text to replace.
*/
public BasicCompletion(CompletionProvider provider, String replacementText){
this(provider, replacementText, null);
}
/**
* Constructor.
*
* @param provider The parent completion provider.
* @param replacementText The text to replace.
* @param shortDesc A short description of the completion. This will be
* displayed in the completion list. This may be null.
*/
public BasicCompletion(CompletionProvider provider, String replacementText,
String shortDesc) {
this(provider, replacementText, shortDesc, null);
}
/**
* Constructor.
*
* @param provider The parent completion provider.
* @param replacementText The text to replace.
* @param shortDesc A short description of the completion. This will be
* displayed in the completion list. This may be null.
* @param summary The summary of this completion. This should be HTML.
* This may be null.
*/
public BasicCompletion(CompletionProvider provider, String replacementText,
String shortDesc, String summary) {
super(provider);
this.replacementText = replacementText;
this.shortDesc = shortDesc;
this.summary = summary;
}
/**
* {@inheritDoc}
*/
public String getReplacementText() {
return replacementText;
}
/**
* Returns the short description of this completion, usually used in
* the completion choices list.
*
* @return The short description, or null if there is none.
* @see #setShortDescription(String)
*/
public String getShortDescription() {
return shortDesc;
}
/**
* {@inheritDoc}
*/
public String getSummary() {
return summary;
}
/**
* Sets the short description of this completion.
*
* @param shortDesc The short description of this completion.
* @see #getShortDescription()
*/
public void setShortDescription(String shortDesc) {
this.shortDesc = shortDesc;
}
/**
* Sets the summary for this completion.
*
* @param summary The summary for this completion.
* @see #getSummary()
*/
public void setSummary(String summary) {
this.summary = summary;
}
/**
* Returns a string representation of this completion. If the short
* description is not null, this method will return:
*
* getInputText() + " - " + shortDesc
*
* otherwise, it will return getInputText().
*
* @return A string representation of this completion.
*/
@Override
public String toString() {
if (shortDesc==null) {
return getInputText();
}
return getInputText() + " - " + shortDesc;
}
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/Completion.java 0000664 0000000 0000000 00000011626 12207001023 0024571 0 ustar 00root root 0000000 0000000 /*
* 12/21/2008
*
* Completion.java - Represents a single completion choice.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import javax.swing.Icon;
import javax.swing.text.JTextComponent;
/**
* Represents a completion choice. A {@link CompletionProvider} returns lists
* of objects implementing this interface. A Completion contains the
* following information:
*
*
*
*
* @author Robert Futrell
* @version 1.0
* @see AbstractCompletion
*/
public interface Completion extends Comparablenull. It may also be
* lazily generated to cut down on memory usage.
* getProvider().getAlreadyEnteredText(comp).
*
* @param comp The text component.
* @return The already-entered portion of this completion.
*/
public String getAlreadyEntered(JTextComponent comp);
/**
* Returns the icon to use for this completion.
*
* @return The icon, or null for none.
*/
public Icon getIcon();
/**
* Returns the text that the user has to (start) typing for this completion
* to be offered. Note that this will usually be the same value as
* {@link #getReplacementText()}, but not always (a completion could be
* a way to implement shorthand, for example, "sysout" mapping
* to "System.out.println(").
*
* @return The text the user has to (start) typing for this completion to
* be offered.
* @see #getReplacementText()
*/
public String getInputText();
/**
* Returns the provider that returned this completion.
*
* @return The provider.
*/
public CompletionProvider getProvider();
/**
* Returns the "relevance" of this completion. This is used when sorting
* completions by their relevance. It is an abstract concept that may
* mean different things to different languages, and may depend on the
* context of the completion.0. The
* higher the value returned by this method, the higher up in the list
* this completion will be; the lower the value returned, the lower it will
* be. Completions with equal relevance values will be
* sorted alphabetically.
*
* @return The relevance of this completion.
*/
public int getRelevance();
/**
* Returns the text to insert as the result of this auto-completion. This
* is the "complete" text, including any text that replaces what the user
* has already typed.
*
* @return The replacement text.
* @see #getInputText()
*/
public String getReplacementText();
/**
* Returns the description of this auto-complete choice. This can be
* used in a popup "description window."
*
* @return This item's description. This should be HTML. It may be
* null if there is no description for this
* completion.
*/
public String getSummary();
/**
* Returns the tool tip text to display for mouse hovers over this
* completion.null if
* none.
*/
public String getToolTipText();
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/CompletionCellRenderer.java 0000664 0000000 0000000 00000041505 12207001023 0027057 0 ustar 00root root 0000000 0000000 /*
* 12/23/2008
*
* CompletionCellRenderer.java - Cell renderer that can render the standard
* completion types like Eclipse or NetBeans does.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import java.awt.Color;
import java.awt.Component;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Rectangle;
import javax.swing.DefaultListCellRenderer;
import javax.swing.Icon;
import javax.swing.JList;
import javax.swing.SwingUtilities;
import javax.swing.plaf.basic.BasicHTML;
import javax.swing.text.View;
/**
* A cell renderer that adds some pizazz when rendering the standard
* {@link Completion} types, like Eclipse and NetBeans do. Specifically,
* this renderer handles:
*
*
*
*
* @author Robert Futrell
* @version 1.0
*/
public class CompletionCellRenderer extends DefaultListCellRenderer {
/**
* The alternating background color, or null if alternating
* row colors should not be used.
*/
private static Color altBG;
/**
* The font to use when rendering items, or null if the
* list's default font should be used.
*/
private Font font;
/**
* Whether to display the types of fields and return types of functions
* in the completion text.
*/
private boolean showTypes;
/**
* The color to use when rendering types in completion text.
*/
private String typeColor;
/**
* During rendering, whether the item being rendered is selected.
*/
private boolean selected;
/**
* During rendering, this is the "real" background color of the item being
* rendered (i.e., what its background color is if it isn't selected).
*/
private Color realBG;
/**
* The color to use for function arguments.
*/
private String paramColor;
/**
* Used in rendering calculations.
*/
private Rectangle paintTextR;
/**
* An optional delegate renderer (primarily for Substance).
*/
private DefaultListCellRenderer delegate;
private static final String SUBSTANCE_RENDERER_CLASS_NAME =
"org.pushingpixels.substance.api.renderers.SubstanceDefaultListCellRenderer";
/**
* Keeps the HTML descriptions from "wrapping" in the list, which cuts off
* words.
*/
private static final String PREFIX = "DefaultListCellRenderers. Everything except for the text
* rendering will be done by the delegate. In almost all scenarios, you
* will want to use the no-argument constructor instead of this one.
*
* @param delegate The delegate renderer.
* @see #delegateToSubstanceRenderer()
*/
public CompletionCellRenderer(DefaultListCellRenderer delegate) {
setDelegateRenderer(delegate);
init();
}
/**
* Returns a decent "parameter" color based on the current default
* foreground color.
*
* @return The parameter color to use.
*/
private String createParamColor() {
return Util.isLightForeground(getForeground()) ?
Util.getHexString(Util.getHyperlinkForeground()): "#aa0077";
}
/**
* Returns a decent "type" color based on the current default foreground
* color.
*
* @return The type color to use.
*/
private String createTypeColor() {
return "#808080";
}
/**
* Attempts to delegate rendering to a Substance cell renderer. This
* should only be called if Substance is known to be on the classpath.
*
* @throws Exception If Substance is not on the classpath, or some other
* error occurs creating the Substance cell renderer.
* @see Util#getUseSubstanceRenderers()
* @see #setDelegateRenderer(DefaultListCellRenderer)
*/
public void delegateToSubstanceRenderer() throws Exception {
Class clazz = Class.forName(SUBSTANCE_RENDERER_CLASS_NAME);
DefaultListCellRenderer delegate =
(DefaultListCellRenderer)clazz.newInstance();
setDelegateRenderer(delegate);
}
/**
* Returns the background color to use on alternating lines.
*
* @return The alternate background color. If this is null,
* alternating colors are not used.
* @see #setAlternateBackground(Color)
*/
public static Color getAlternateBackground() {
return altBG;
}
/**
* Returns the delegate renderer, or null if there is none.
*
* @return The delegate renderer.
* @see #setDelegateRenderer(DefaultListCellRenderer)
*/
public DefaultListCellRenderer getDelegateRenderer() {
return delegate;
}
/**
* Returns the font used when rendering completions.
*
* @return The font. If this is null, then the default list
* font is used.
* @see #setDisplayFont(Font)
*/
public Font getDisplayFont() {
return font;
}
/**
* Returns the renderer.
*
* @param list The list of choices being rendered.
* @param value The {@link Completion} being rendered.
* @param index The index into list being rendered.
* @param selected Whether the item is selected.
* @param hasFocus Whether the item has focus.
*/
@Override
public Component getListCellRendererComponent(JList list, Object value,
int index, boolean selected, boolean hasFocus) {
super.getListCellRendererComponent(list,value,index,selected,hasFocus);
if (font!=null) {
setFont(font); // Overrides super's setFont(list.getFont()).
}
this.selected = selected;
this.realBG = altBG!=null && (index&1)==1 ? altBG : list.getBackground();
Completion c = (Completion)value;
setIcon(c.getIcon());
if (c instanceof FunctionCompletion) {
FunctionCompletion fc = (FunctionCompletion)value;
prepareForFunctionCompletion(list, fc, index, selected, hasFocus);
}
else if (c instanceof VariableCompletion) {
VariableCompletion vc = (VariableCompletion)value;
prepareForVariableCompletion(list, vc, index, selected, hasFocus);
}
else if (c instanceof TemplateCompletion) {
TemplateCompletion tc = (TemplateCompletion)value;
prepareForTemplateCompletion(list, tc, index, selected, hasFocus);
}
else if (c instanceof MarkupTagCompletion) {
MarkupTagCompletion mtc = (MarkupTagCompletion)value;
prepareForMarkupTagCompletion(list, mtc, index, selected, hasFocus);
}
else {
prepareForOtherCompletion(list, c, index, selected, hasFocus);
}
// A delegate renderer might do its own alternate row striping
// (Substance does).
if (delegate!=null) {
delegate.getListCellRendererComponent(list, getText(), index,
selected, hasFocus);
delegate.setFont(getFont());
delegate.setIcon(getIcon());
return delegate;
}
if (!selected && (index&1)==1 && altBG!=null) {
setBackground(altBG);
}
return this;
}
/**
* Returns whether the types of fields and return types of methods are
* shown in the completion text.
*
* @return Whether to show the types.
* @see #setShowTypes(boolean)
*/
public boolean getShowTypes() {
return showTypes;
}
private void init() {
//setDisplayFont(new Font("Monospaced", Font.PLAIN, 12));
setShowTypes(true);
typeColor = createTypeColor();
paramColor = createParamColor();
paintTextR = new Rectangle();
}
@Override
protected void paintComponent(Graphics g) {
//super.paintComponent(g);
g.setColor(realBG);
int iconW = 0;
if (getIcon()!=null) {
iconW = getIcon().getIconWidth();
}
if (selected && iconW>0) { // The icon area is never in the "selection"
g.fillRect(0, 0, iconW, getHeight());
g.setColor(getBackground());
g.fillRect(iconW,0, getWidth()-iconW,getHeight());
}
else {
g.setColor(getBackground());
g.fillRect(0, 0, getWidth(), getHeight());
}
if (getIcon()!=null) {
getIcon().paintIcon(this, g, 0, 0);
}
String text = getText();
if (text != null) {
paintTextR.setBounds(iconW,0, getWidth()-iconW,getHeight());
paintTextR.x += 3; // Force a slight margin
int space = paintTextR.height - g.getFontMetrics().getHeight();
View v = (View)getClientProperty(BasicHTML.propertyKey);
if (v != null) {
// HTML rendering doesn't auto-center vertically, for some
// reason
paintTextR.y += space/2;
paintTextR.height -= space;
v.paint(g, paintTextR);
}
else {
int textX = paintTextR.x;
int textY = paintTextR.y;// + g.getFontMetrics().getAscent();
//System.out.println(g.getFontMetrics().getAscent());
g.drawString(text, textX, textY);
}
}
}
/**
* Prepares this renderer to display a function completion.
*
* @param list The list of choices being rendered.
* @param fc The completion to render.
* @param index The index into list being rendered.
* @param selected Whether the item is selected.
* @param hasFocus Whether the item has focus.
*/
protected void prepareForFunctionCompletion(JList list,
FunctionCompletion fc, int index, boolean selected, boolean hasFocus) {
StringBuilder sb = new StringBuilder(PREFIX);
sb.append(fc.getName());
char paramListStart = fc.getProvider().getParameterListStart();
if (paramListStart!=0) { // 0 => no start char
sb.append(paramListStart);
}
int paramCount = fc.getParamCount();
for (int i=0; ilist being rendered.
* @param selected Whether the item is selected.
* @param hasFocus Whether the item has focus.
*/
protected void prepareForMarkupTagCompletion(JList list,
MarkupTagCompletion mc, int index, boolean selected, boolean hasFocus) {
StringBuilder sb = new StringBuilder(PREFIX);
sb.append(mc.getName());
setText(sb.toString());
}
/**
* Prepares this renderer to display a completion not specifically handled
* elsewhere.
*
* @param list The list of choices being rendered.
* @param c The completion to render.
* @param index The index into list being rendered.
* @param selected Whether the item is selected.
* @param hasFocus Whether the item has focus.
*/
protected void prepareForOtherCompletion(JList list,
Completion c, int index, boolean selected, boolean hasFocus) {
StringBuilder sb = new StringBuilder(PREFIX);
sb.append(c.getInputText());
if (c instanceof BasicCompletion) {
String definition = ((BasicCompletion)c).getShortDescription();
if (definition!=null) {
sb.append(" - ");
if (!selected) {
sb.append("");
}
sb.append(definition);
if (!selected) {
sb.append("");
}
}
}
setText(sb.toString());
}
/**
* Prepares this renderer to display a template completion.
*
* @param list The list of choices being rendered.
* @param tc The completion to render.
* @param index The index into list being rendered.
* @param selected Whether the item is selected.
* @param hasFocus Whether the item has focus.
*/
protected void prepareForTemplateCompletion(JList list,
TemplateCompletion tc, int index, boolean selected, boolean hasFocus) {
StringBuilder sb = new StringBuilder(PREFIX);
sb.append(tc.getInputText());
String definition = tc.getShortDescription();
if (definition!=null) {
sb.append(" - ");
if (!selected) {
sb.append("");
}
sb.append(definition);
if (!selected) {
sb.append("");
}
}
setText(sb.toString());
}
/**
* Prepares this renderer to display a variable completion.
*
* @param list The list of choices being rendered.
* @param vc The completion to render.
* @param index The index into list being rendered.
* @param selected Whether the item is selected.
* @param hasFocus Whether the item has focus.
*/
protected void prepareForVariableCompletion(JList list,
VariableCompletion vc, int index, boolean selected, boolean hasFocus) {
StringBuilder sb = new StringBuilder(PREFIX);
sb.append(vc.getName());
if (getShowTypes() && vc.getType()!=null) {
sb.append(" : ");
if (!selected) {
sb.append("");
}
sb.append(vc.getType());
if (!selected) {
sb.append("");
}
}
setText(sb.toString());
}
/**
* Sets the background color to use on alternating lines.
*
* @param altBG The new alternate background color. If this is
* null, alternating lines will not use different
* background colors.
* @see #getAlternateBackground()
*/
public static void setAlternateBackground(Color altBG) {
CompletionCellRenderer.altBG = altBG;
}
/**
* Sets the delegate renderer. Most users will never use this method; it
* is primarily a hook for Substance and other Look and Feels whose
* renderers look drastically different from the standard
* DefaultListCellRenderer.
*
* @param delegate The new delegate renderer. If this is null,
* the default rendering of this component is used.
* @see #getDelegateRenderer()
* @see #delegateToSubstanceRenderer()
*/
public void setDelegateRenderer(DefaultListCellRenderer delegate) {
this.delegate = delegate;
}
/**
* Sets the font to use when rendering completion items.
*
* @param font The font to use. If this is null, then
* the default list font is used.
* @see #getDisplayFont()
*/
public void setDisplayFont(Font font) {
this.font = font;
}
/**
* Sets the icon to display based off of a completion, falling back to a
* default icon if the completion has no icon.
*
* @param completion The completion to check.
* @param defaultIcon The icon to use if completion does not
* specify an icon.
*/
protected void setIconWithDefault(Completion completion, Icon defaultIcon) {
Icon icon = completion.getIcon();
setIcon(icon!=null ? icon : defaultIcon);
}
/**
* Sets the color to use for function arguments.
*
* @param color The color to use. This is ignored if null.
* @see #setTypeColor(Color)
*/
public void setParamColor(Color color) {
if (color!=null) {
paramColor = Util.getHexString(color);
}
}
/**
* Sets whether the types of fields and return types of methods are
* shown in the completion text.
*
* @param show Whether to show the types.
* @see #getShowTypes()
*/
public void setShowTypes(boolean show) {
this.showTypes = show;
}
/**
* Sets the color to use for function/field types. Note that if
* {@link #getShowTypes()} returns false, this property
* effectively does nothing.
*
* @param color The color to use for types. This is ignored if
* null.
* @see #setShowTypes(boolean)
* @see #setParamColor(Color)
*/
public void setTypeColor(Color color) {
if (color!=null) {
typeColor = Util.getHexString(color);
}
}
/**
* Overridden to update our delegate, if necessary.
*/
@Override
public void updateUI() {
super.updateUI();
if (delegate!=null) {
SwingUtilities.updateComponentTreeUI(delegate);
}
paramColor = createParamColor();
}
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/CompletionListModel.java 0000664 0000000 0000000 00000003352 12207001023 0026403 0 ustar 00root root 0000000 0000000 /*
* 12/22/2008
*
* CompletionListModel.java - A model that allows bulk addition of elements.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.swing.AbstractListModel;
/**
* A list model implementation that allows the bulk addition of elements.
* This is the only feature missing from DefaultListModel that
* we need.
*
* @author Robert Futrell
* @version 1.0
*/
class CompletionListModel extends AbstractListModel {
/**
* Container for items in this model.
*/
private Listnull means nothing
* should be auto-completed; a value of an empty string
* ("") means auto-completion should still be
* considered (i.e., all possible choices are valid).
*/
public String getAlreadyEnteredText(JTextComponent comp);
/**
* Gets the possible completions for the text component at the current
* caret position.
*
* @param comp The text component.
* @return The list of {@link Completion}s. If no completions are
* available, this may be null.
*/
public Listnull if the default should
* be used.
* @see #setListCellRenderer(ListCellRenderer)
*/
public ListCellRenderer getListCellRenderer();
/**
* Returns an object that can return a list of completion choices for
* parameters. This is used when a user code-completes a parameterized
* completion, such as a function or method. For any parameter to the
* function/method, this object can return possible completions.
*
* @return The parameter choices provider, or null if
* none is installed.
*/
public ParameterChoicesProvider getParameterChoicesProvider();
/**
* Returns a list of parameterized completions that have been entered
* at the current caret position of a text component (and thus can have
* their completion choices displayed).
*
* @param tc The text component.
* @return The list of {@link ParameterizedCompletion}s. If no completions
* are available, this may be null.
*/
public List)'.
* @see #getParameterListStart()
* @see #getParameterListSeparator()
* @see #setParameterizedCompletionParams(char, String, char)
*/
public char getParameterListEnd();
/**
* Returns the text that separates parameters to a function or method.
*
* @return The text that separates parameters, for example,
* ", ".
* @see #getParameterListStart()
* @see #getParameterListEnd()
* @see #setParameterizedCompletionParams(char, String, char)
*/
public String getParameterListSeparator();
/**
* Returns the text that marks the start of a list of parameters to a
* function or method.
*
* @return The text for a parameter list start, for example,
* "(".
* @see #getParameterListEnd()
* @see #getParameterListSeparator()
* @see #setParameterizedCompletionParams(char, String, char)
*/
public char getParameterListStart();
/**
* Returns the parent completion provider.
*
* @return The parent completion provider.
* @see #setParent(CompletionProvider)
*/
public CompletionProvider getParent();
/**
* This method is called if auto-activation is enabled in the parent
* {@link AutoCompletion} after the user types a single character. This
* provider should check the text at the current caret position of the
* text component, and decide whether auto-activation would be appropriate
* here. For example, a CompletionProvider for Java might
* want to return true for this method only if the last
* character typed was a '.'.
*
* @param tc The text component.
* @return Whether auto-activation would be appropriate.
*/
public boolean isAutoActivateOkay(JTextComponent tc);
/**
* Sets the renderer to use when displaying completion choices.
*
* @param r The renderer to use.
* @see #getListCellRenderer()
*/
public void setListCellRenderer(ListCellRenderer r);
/**
* Sets the values used to identify and insert "parameterized completions"
* (e.g. functions or methods). If this method isn't called, functions
* and methods will not have their parameters auto-completed.
*
* @param listStart The character that marks the beginning of a list of
* parameters, such as '(' in C or Java.
* @param separator Text that should separate parameters in a parameter
* list when one is inserted. For example, ", ".
* @param listEnd The character that marks the end of a list of parameters,
* such as ')' in C or Java.
* @throws IllegalArgumentException If either listStart or
* listEnd is not printable ASCII, or if
* separator is null or an empty string.
* @see #clearParameterizedCompletionParams()
*/
public void setParameterizedCompletionParams(char listStart,
String separator, char listEnd);
/**
* Sets the parent completion provider.
*
* @param parent The parent provider. null means there will
* be no parent provider.
* @see #getParent()
*/
public void setParent(CompletionProvider parent);
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/CompletionProviderBase.java 0000664 0000000 0000000 00000014401 12207001023 0027071 0 ustar 00root root 0000000 0000000 /*
* 02/06/2010
*
* CompletionProviderBase.java - Base completion provider implementation.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.swing.ListCellRenderer;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.JTextComponent;
import javax.swing.text.Segment;
/**
* A base class for all standard completion providers. This class implements
* functionality that should be sharable across all CompletionProvider
* implementations.
*
* @author Robert Futrell
* @version 1.0
* @see AbstractCompletionProvider
*/
public abstract class CompletionProviderBase implements CompletionProvider {
/**
* The parent completion provider.
*/
private CompletionProvider parent;
/**
* The renderer to use for completions from this provider. If this is
* null, a default renderer is used.
*/
private ListCellRenderer listCellRenderer;
/**
* Text that marks the beginning of a parameter list, for example, '('.
*/
private char paramListStart;
/**
* Text that marks the end of a parameter list, for example, ')'.
*/
private char paramListEnd;
/**
* Text that separates items in a parameter list, for example, ", ".
*/
private String paramListSeparator;
/**
* Whether auto-activation should occur after letters.
*/
private boolean autoActivateAfterLetters;
/**
* Non-letter chars that should cause auto-activation to occur.
*/
private String autoActivateChars;
/**
* Provides completion choices for a parameterized completion's parameters.
*/
private ParameterChoicesProvider paramChoicesProvider;
/**
* A segment to use for fast char access.
*/
private Segment s = new Segment();
protected static final String EMPTY_STRING = "";
/**
* Comparator used to sort completions by their relevance before sorting
* them lexicographically.
*/
private static final Comparatorothers
* to ".", to allow auto-activation for members of an object.
*
* @param letters Whether auto-activation should occur after any letter.
* @param others A string of (non-letter) chars that auto-activation should
* occur after. This may be null.
*/
public void setAutoActivationRules(boolean letters, String others) {
autoActivateAfterLetters = letters;
autoActivateChars = others;
}
/**
* Sets the param choices provider. This is used when a user
* code-completes a parameterized completion, such as a function or method.
* For any parameter to the function/method, this object can return
* possible completions.
*
* @param pcp The parameter choices provider, or null for
* none.
* @see #getParameterChoicesProvider()
*/
public void setParameterChoicesProvider(ParameterChoicesProvider pcp) {
paramChoicesProvider = pcp;
}
/**
* {@inheritDoc}
*/
public void setListCellRenderer(ListCellRenderer r) {
listCellRenderer = r;
}
/**
* {@inheritDoc}
*/
public void setParameterizedCompletionParams(char listStart,
String separator, char listEnd) {
if (listStart<0x20 || listStart==0x7F) {
throw new IllegalArgumentException("Invalid listStart");
}
if (listEnd<0x20 || listEnd==0x7F) {
throw new IllegalArgumentException("Invalid listEnd");
}
if (separator==null || separator.length()==0) {
throw new IllegalArgumentException("Invalid separator");
}
paramListStart = listStart;
paramListSeparator = separator;
paramListEnd = listEnd;
}
/**
* {@inheritDoc}
*/
public void setParent(CompletionProvider parent) {
this.parent = parent;
}
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/CompletionXMLParser.java 0000664 0000000 0000000 00000026337 12207001023 0026334 0 ustar 00root root 0000000 0000000 /*
* 02/06/2010
*
* CompletionXMLParser.java - Parses XML representing code completion for a
* C-like language.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.List;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.helpers.DefaultHandler;
/**
* Parser for an XML file describing a procedural language such as C. XML
* files will be validated against the CompletionXml.dtd DTD
* found in this package.
*
* @author Robert Futrell
* @version 1.0
*/
public class CompletionXMLParser extends DefaultHandler {
/**
* The completions found after parsing the XML.
*/
private Listnull, then a default class loader is used. This field
* will usually be null.
*/
private static ClassLoader DEFAULT_COMPLETION_CLASS_LOADER;
/**
* Constructor.
*
* @param provider The provider to get completions for.
* @see #reset(CompletionProvider)
*/
public CompletionXMLParser(CompletionProvider provider) {
this(provider, null);
}
/**
* Constructor.
*
* @param provider The provider to get completions for.
* @param cl The class loader to use, if necessary, when loading classes
* from the XML (custom {@link FunctionCompletion}s, for example).
* This may be null if the default is to be used, or
* if the XML does not define specific classes for completion types.
* @see #reset(CompletionProvider)
*/
public CompletionXMLParser(CompletionProvider provider, ClassLoader cl) {
this.provider = provider;
this.completionCL = cl;
if (completionCL==null) {
// May also be null, but that's okay.
completionCL = DEFAULT_COMPLETION_CLASS_LOADER;
}
completions = new ArrayListnull if none was specified.
*/
public String getParamSeparator() {
return paramSeparator;
}
/**
* Returns the parameter start character specified.
*
* @return The character, or 0 if none was specified.
*/
public char getParamStartChar() {
return paramStartChar;
}
private static final char getSingleChar(String str) {
return str.length()==1 ? str.charAt(0) : 0;
}
/**
* Resets this parser to grab more completions.
*
* @param provider The new provider to get completions for.
*/
public void reset(CompletionProvider provider) {
this.provider = provider;
completions.clear();
doingKeywords = inKeyword = gettingDesc = gettingParams = inParam =
gettingParamDesc = false;
paramStartChar = paramEndChar = 0;
paramSeparator = null;
}
@Override
public InputSource resolveEntity(String publicID,
String systemID) throws SAXException {
return new InputSource(getClass().
getResourceAsStream("CompletionXml.dtd"));
}
/**
* Sets the class loader to use when loading custom classes to use for
* various {@link Completion} types, such as {@link FunctionCompletion}s,
* from XML.null, then
* a default is used.
*/
public static void setDefaultCompletionClassLoader(ClassLoader cl) {
DEFAULT_COMPLETION_CLASS_LOADER = cl;
}
/**
* Called when an element starts.
*/
@Override
public void startElement(String uri, String localName, String qName,
Attributes attrs) {
if ("keywords".equals(qName)) {
doingKeywords = true;
}
else if (doingKeywords) {
if ("keyword".equals(qName)) {
name = attrs.getValue("name");
type = attrs.getValue("type");
returnType = attrs.getValue("returnType");
params.clear();
definedIn = attrs.getValue("definedIn");
inKeyword = true;
}
else if (inKeyword) {
if ("returnValDesc".equals(qName)) {
gettingReturnValDesc = true;
}
else if ("params".equals(qName)) {
gettingParams = true;
}
else if (gettingParams) {
if ("param".equals(qName)) {
paramName = attrs.getValue("name");
paramType = attrs.getValue("type");
inParam = true;
}
if (inParam) {
if ("desc".equals(qName)) {
gettingParamDesc = true;
}
}
}
else if ("desc".equals(qName)) {
gettingDesc = true;
}
}
}
else if ("environment".equals(qName)) {
paramStartChar = getSingleChar(attrs.getValue("paramStartChar"));
paramEndChar = getSingleChar(attrs.getValue("paramEndChar"));
paramSeparator = attrs.getValue("paramSeparator");
//paramTerminal = attrs.getValua("terminal");
}
else if ("completionTypes".equals(qName)) {
inCompletionTypes = true;
}
else if (inCompletionTypes) {
if ("functionCompletionType".equals(qName)) {
funcCompletionType = attrs.getValue("type");
}
}
}
@Override
public void warning(SAXParseException e) throws SAXException {
throw e;
}
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/CompletionXml.dtd 0000664 0000000 0000000 00000002260 12207001023 0025076 0 ustar 00root root 0000000 0000000
autocomplete-2.5.0/src/org/fife/ui/autocomplete/DefaultCompletionProvider.java 0000664 0000000 0000000 00000025024 12207001023 0027606 0 ustar 00root root 0000000 0000000 /*
* 12/21/2008
*
* DefaultCompletionProvider.java - A basic completion provider implementation.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import java.awt.Point;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.Element;
import javax.swing.text.JTextComponent;
import javax.swing.text.Segment;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.SAXException;
/**
* A basic completion provider implementation. This provider has no
* understanding of language semantics. It simply checks the text entered up
* to the caret position for a match against known completions. This is all
* that is needed in the majority of cases.
*
* @author Robert Futrell
* @version 1.0
*/
public class DefaultCompletionProvider extends AbstractCompletionProvider {
protected Segment seg;
/**
* Used to speed up {@link #getCompletionsAt(JTextComponent, Point)}.
*/
private String lastCompletionsAtText;
/**
* Used to speed up {@link #getCompletionsAt(JTextComponent, Point)},
* since this may be called multiple times in succession (this is usually
* called by JTextComponent.getToolTipText(), and if the user
* wiggles the mouse while a tool tip is displayed, this method gets
* repeatedly called. It can be costly so we try to speed it up a tad).
*/
private Listnull, no completions will be known.
* @see BasicCompletion
*/
public DefaultCompletionProvider(String[] words) {
init();
addWordCompletions(words);
}
/**
* Returns the text just before the current caret position that could be
* the start of something auto-completable.Character.isLetterOrDigit(ch) || ch=='_'". Subclasses
* can override this method to change what characters are matched.
*
* @param ch The character.
* @return Whether the character is valid.
*/
protected boolean isValidChar(char ch) {
return Character.isLetterOrDigit(ch) || ch=='_';
}
/**
* Loads completions from an XML file. The XML should validate against
* CompletionXml.dtd.
*
* @param file An XML file to load from.
* @throws IOException If an IO error occurs.
*/
public void loadFromXML(File file) throws IOException {
BufferedInputStream bin = new BufferedInputStream(
new FileInputStream(file));
try {
loadFromXML(bin);
} finally {
bin.close();
}
}
/**
* Loads completions from an XML input stream. The XML should validate
* against CompletionXml.dtd.
*
* @param in The input stream to read from.
* @throws IOException If an IO error occurs.
*/
public void loadFromXML(InputStream in) throws IOException {
loadFromXML(in, null);
}
/**
* Loads completions from an XML input stream. The XML should validate
* against CompletionXml.dtd.
*
* @param in The input stream to read from.
* @param cl The class loader to use when loading any extra classes defined
* in the XML, such as custom {@link FunctionCompletion}s. This
* may be null if the default is to be used, or if no
* custom completions are defined in the XML.
* @throws IOException If an IO error occurs.
*/
public void loadFromXML(InputStream in, ClassLoader cl) throws IOException {
//long start = System.currentTimeMillis();
SAXParserFactory factory = SAXParserFactory.newInstance();
factory.setValidating(true);
CompletionXMLParser handler = new CompletionXMLParser(this, cl);
BufferedInputStream bin = new BufferedInputStream(in);
try {
SAXParser saxParser = factory.newSAXParser();
saxParser.parse(bin, handler);
ListCompletionXml.dtd.
*
* @param resource A resource the current ClassLoader can get to.
* @throws IOException If an IO error occurs.
*/
public void loadFromXML(String resource) throws IOException {
ClassLoader cl = getClass().getClassLoader();
InputStream in = cl.getResourceAsStream(resource);
if (in==null) {
File file = new File(resource);
if (file.isFile()) {
in = new FileInputStream(file);
}
else {
throw new IOException("No such resource: " + resource);
}
}
BufferedInputStream bin = new BufferedInputStream(in);
try {
loadFromXML(bin);
} finally {
bin.close();
}
}
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/DelegatingCellRenderer.java 0000664 0000000 0000000 00000004672 12207001023 0027015 0 ustar 00root root 0000000 0000000 /*
* 12/22/2008
*
* DelegatingCellRenderer.java - A renderer for Completions that will delegate
* to the Completion's provider's renderer, if there is one.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import java.awt.Component;
import javax.swing.DefaultListCellRenderer;
import javax.swing.JComponent;
import javax.swing.JList;
import javax.swing.ListCellRenderer;
/**
* List cell renderer that delegates to a {@link CompletionProvider}'s
* renderer, if it has one. If it doesn't, it calls into a fallback renderer.
* If a fallback renderer isn't specified, it simply renders
* (({@link Completion})value).toString().
*
* @author Robert Futrell
* @version 1.0
*/
class DelegatingCellRenderer extends DefaultListCellRenderer {
/**
* The renderer to fall back on if one isn't specified by a provider.
* This is usually this.
*/
private ListCellRenderer fallback;
/**
* Returns the fallback cell renderer.
*
* @return The fallback cell renderer.
* @see #setFallbackCellRenderer(ListCellRenderer)
*/
public ListCellRenderer getFallbackCellRenderer() {
return fallback;
}
/**
* {@inheritDoc}
*/
@Override
public Component getListCellRendererComponent(JList list, Object value,
int index, boolean selected, boolean hasFocus) {
Completion c = (Completion)value;
CompletionProvider p = c.getProvider();
ListCellRenderer r = p.getListCellRenderer();
if (r!=null) {
return r.getListCellRendererComponent(list, value, index, selected,
hasFocus);
}
if (fallback==null) {
return super.getListCellRendererComponent(list, value, index,
selected, hasFocus);
}
return fallback.getListCellRendererComponent(list, value, index,
selected, hasFocus);
}
/**
* Sets the fallback cell renderer.
*
* @param fallback The fallback cell renderer. If this is
* null, this will be used.
* @see #getFallbackCellRenderer()
*/
public void setFallbackCellRenderer(ListCellRenderer fallback) {
this.fallback = fallback;
}
/**
* {@inheritDoc}
*/
@Override
public void updateUI() {
super.updateUI();
if ((fallback instanceof JComponent) && fallback!=this) {
((JComponent)fallback).updateUI();
}
}
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/DescWindowCallback.java 0000664 0000000 0000000 00000001611 12207001023 0026134 0 ustar 00root root 0000000 0000000 /*
* 05/11/2012
*
* Copyright (C) 2012 Robert Futrell
* robert_futrell at users.sourceforge.net
* http://fifesoft.com/rsyntaxtextarea
*
* This library is distributed under a modified BSD license. See the included
* RSTALanguageSupport.License.txt file for details.
*/
package org.fife.ui.autocomplete;
/**
* Passed to {@link ExternalURLHandler}s as a way for them to display a summary
* for a new completion in response to a link event.
*
* @author Robert Futrell
* @version 1.0
* @see ExternalURLHandler
*/
public interface DescWindowCallback {
/**
* Callback allowing a new code completion's description to be displayed
* in the description window.
*
* @param completion The new completion.
* @param anchor The anchor to scroll to, or null if none.
*/
public void showSummaryFor(Completion completion, String anchor);
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/EmptyIcon.java 0000664 0000000 0000000 00000001661 12207001023 0024365 0 ustar 00root root 0000000 0000000 /*
* 04/29/2010
*
* EmptyIcon.java - The canonical icon that paints nothing.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import java.awt.Component;
import java.awt.Graphics;
import java.io.Serializable;
import javax.swing.Icon;
/**
* A standard icon that doesn't paint anything. This can be used when some
* Completions have icons and others don't, to visually align the
* text of all completions.
*
* @author Robert Futrell
* @version 1.0
*/
public class EmptyIcon implements Icon, Serializable {
private int size;
public EmptyIcon(int size) {
this.size = size;
}
public int getIconHeight() {
return size;
}
public int getIconWidth() {
return size;
}
public void paintIcon(Component c, Graphics g, int x, int y) {
}
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/ExternalURLHandler.java 0000664 0000000 0000000 00000003070 12207001023 0026115 0 ustar 00root root 0000000 0000000 /*
* 12/23/2008
*
* ExternalURLHandler.java - Implementations can be registered as a callback
* to handle the user clicking on external URL's.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import javax.swing.event.HyperlinkEvent;
/**
* A callback for when an external URL is clicked in the description window.
* If no handler is installed, and if running in Java 6, the system default
* web browser is used to open the URL. If not running Java 6, nothing will
* happen. If you want browser support for pre-Java 6 JRE's, you will need
* to register one of these callbacks on your {@link AutoCompletion}, and
* open the URL in a web browser yourself.ExternalURLHandler to handle
* navigating through linked documentation of objects, functions, etc.
*
* @author Robert Futrell
* @version 1.0
* @see AutoCompletion#setExternalURLHandler(ExternalURLHandler)
*/
public interface ExternalURLHandler {
/**
* Called when an external URL is clicked in the description window.
*
* @param e The event containing the hyperlink clicked.
* @param c The completion currently being displayed.
* @param callback Allows you to display new content in the description
* window.
*/
public void urlClicked(HyperlinkEvent e, Completion c,
DescWindowCallback callback);
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/FastListUI.java 0000664 0000000 0000000 00000013267 12207001023 0024452 0 ustar 00root root 0000000 0000000 /*
* 04/26/2010
*
* FastListUI.java - A JList UI implementation that computes the preferred size
* of all cells really fast, to facilitate lists of possibly thousands of items
* rendered with HTML, which is slow with BasicListUI extensions.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.SystemColor;
import javax.swing.JViewport;
import javax.swing.ListCellRenderer;
import javax.swing.ListModel;
import javax.swing.UIManager;
import javax.swing.plaf.basic.BasicListUI;
/**
* A custom list UI, used by the completion choices list. If the number of
* completion choices is "large," it does a fast estimate of the preferred
* width and height of list items. This allows HTML renderers to be used (such
* as {@link CompletionCellRenderer}), with thousands of completion choices,
* with no performance penalty. With standard BasicListUI subclasses, this can
* cause very poor performance each time the list is displayed, which
* is bad for lists that are repeatedly hidden and re-displayed, such as
* completion choices. This is all because the calculation to get the
* preferred size of each list item, when it is displayed with HTML, is slow.
*
* @author Robert Futrell
* @version 1.0
*/
class FastListUI extends BasicListUI {
/**
* Whether the selection background was overridden (usually because of
* Nimbus) so we know to manually uninstall the color we installed.
*/
private boolean overriddenBackground;
/**
* Whether the selection foreground was overridden (usually because of
* Nimbus) so we know to manually uninstall the color we installed.
*/
private boolean overriddenForeground;
/**
* If there are more than this many completions in a single list, this
* UI will estimate the cell width and height needed for each item instead
* of computing it, for performance reasons.
*/
private static final int ESTIMATION_THRESHOLD = 200;
private Color determineSelectionBackground() {
Color c = UIManager.getColor("List.selectionBackground");
if (c==null) {
c = UIManager.getColor("nimbusSelectionBackground");
if (c==null) { // Not Nimbus, but still need a value - fallback
c = UIManager.getColor("textHighlight");
if (c==null) {
c = SystemColor.textHighlight;
}
}
}
// Nimbus unfortunately requires a Color, not a ColorUIResource, for
// the background override to work. This causes this color to "stick"
// even if the LAF is changed to something else later. "c" here may
// actually be a ColorUIResource
return new Color(c.getRGB());//new ColorUIResource(c);
}
private Color determineSelectionForeground() {
Color c = UIManager.getColor("List.selectionForeground");
if (c==null) {
c = UIManager.getColor("nimbusSelectedText");
if (c==null) { // Not Nimbus, but still need a value - fallback
c = UIManager.getColor("textHighlightText");
if (c==null) {
c = SystemColor.textHighlightText;
}
}
}
// Nimbus unfortunately requires Color, not ColorUIResource, and "c"
// may actually be a ColorUIResource
return new Color(c.getRGB());
}
/**
* Overridden to ensure we have selection background/foreground colors
* defined, even if we're in some weirdo LAF such as Nimbus which doesn't
* define them. Since FastListUI extends BasicListUI, we need these values
* to be defined.
*/
@Override
protected void installDefaults() {
super.installDefaults();
if (list.getSelectionBackground()==null) {
list.setSelectionBackground(determineSelectionBackground());
overriddenBackground = true;
}
if (list.getSelectionForeground()==null) {
list.setSelectionForeground(determineSelectionForeground());
overriddenForeground = true;
}
}
/**
* Overridden to work around a Nimbus issue.
*/
@Override
protected void uninstallDefaults() {
super.uninstallDefaults();
if (overriddenBackground) {
list.setSelectionBackground(null);
}
if (overriddenForeground) {
list.setSelectionForeground(null);
}
}
/**
* Recalculates the cell width and height of each cell in the list. This
* method is overridden to do a fast estimation if the completion list is
* too long, to improve performance for lists with huge amounts of
* completions.
*/
@Override
protected void updateLayoutState() {
ListModel model = list.getModel();
int itemCount = model.getSize();
// If the item count is small enough to run fast on practically all
// machines, go ahead and use the super implementation to determine
// the optimal cell sizes.
if (itemCount
");
sb.append("");
for (int i=0; i
");
}
sb.append("
");
}
if (returnValDesc!=null) {
sb.append("Returns:");
sb.append(returnValDesc);
sb.append("
");
}
}
/**
* Returns the "definition string" for this function completion. For
* example, for the C "printf" function, this would return
* "int printf(const char *, ...)".
*
* @return The definition string.
*/
@Override
public String getDefinitionString() {
StringBuilder sb = new StringBuilder();
// Add the return type if applicable (C macros like NULL have no type).
String type = getType();
if (type!=null) {
sb.append(type).append(' ');
}
// Add the item being described's name.
sb.append(getName());
// Add parameters for functions.
CompletionProvider provider = getProvider();
char start = provider.getParameterListStart();
if (start!=0) {
sb.append(start);
}
for (int i=0; inull if there is none.
* @see #setReturnValueDescription(String)
*/
public String getReturnValueDescription() {
return returnValDesc;
}
/**
* {@inheritDoc}
*/
@Override
public String getSummary() {
StringBuilder sb = new StringBuilder();
addDefinitionString(sb);
if (!possiblyAddDescription(sb)) {
sb.append("
");
}
addParameters(sb);
possiblyAddDefinedIn(sb);
return sb.toString();
}
/**
* {@inheritDoc}
*/
@Override
public String getToolTipText() {
String text = getSummary();
if (text==null) {
text = getDefinitionString();
}
return text;
}
/**
* Sets the parameters to this function.
*
* @param params The parameters. This should be a list of
* {@link ParameterizedCompletion.Parameter}s.
* @see #getParam(int)
* @see #getParamCount()
*/
public void setParams(List
*
*
* This allows for different completion choices in comments than in code,
* for example.null.
*/
public LanguageAwareCompletionProvider(CompletionProvider defaultProvider) {
setDefaultCompletionProvider(defaultProvider);
}
/**
* Calling this method will result in an
* {@link UnsupportedOperationException} being thrown. To set the
* parameter completion parameters, do so on the provider returned by
* {@link #getDefaultCompletionProvider()}.
*
* @throws UnsupportedOperationException Always.
* @see #setParameterizedCompletionParams(char, String, char)
*/
@Override
public void clearParameterizedCompletionParams() {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*/
public String getAlreadyEnteredText(JTextComponent comp) {
if (!(comp instanceof RSyntaxTextArea)) {
return EMPTY_STRING;
}
CompletionProvider provider = getProviderFor(comp);
return provider!=null ? provider.getAlreadyEnteredText(comp) : null;
}
/**
* Returns the completion provider to use for comments.
*
* @return The completion provider to use.
* @see #setCommentCompletionProvider(CompletionProvider)
*/
public CompletionProvider getCommentCompletionProvider() {
return commentCompletionProvider;
}
/**
* {@inheritDoc}
*/
public Listnull.
* @see #getDefaultCompletionProvider()
*/
public void setDefaultCompletionProvider(CompletionProvider provider) {
if (provider==null) {
throw new IllegalArgumentException("provider cannot be null");
}
this.defaultProvider = provider;
}
/**
* Sets the documentation comment completion provider.
*
* @param provider The provider to use in comments.
* @see #getDocCommentCompletionProvider()
*/
public void setDocCommentCompletionProvider(CompletionProvider provider) {
this.docCommentCompletionProvider = provider;
}
/**
* Calling this method will result in an
* {@link UnsupportedOperationException} being thrown. To set the
* parameter completion parameters, do so on the provider returned by
* {@link #getDefaultCompletionProvider()}.
*
* @throws UnsupportedOperationException Always.
* @see #clearParameterizedCompletionParams()
*/
@Override
public void setParameterizedCompletionParams(char listStart,
String separator, char listEnd) {
throw new UnsupportedOperationException();
}
/**
* Sets the completion provider to use while in a string.
*
* @param provider The provider to use.
* @see #getStringCompletionProvider()
*/
public void setStringCompletionProvider(CompletionProvider provider) {
stringCompletionProvider = provider;
}
/**
* Returns the tool tip to display for a mouse event.
* ToolTipManager.sharedInstance().registerComponent(textArea);
*
*
* @param textArea The text area.
* @param e The mouse event.
* @return The tool tip text, or null if none.
*/
public String getToolTipText(RTextArea textArea, MouseEvent e) {
String tip = null;
List
");
sb.append("");
for (int i=0; i
");
}
sb.append("
");
}
}
protected void addDefinitionString(StringBuilder sb) {
sb.append("").append(name).append("");
}
/**
* Returns all attributes of this tag.
*
* @return A list of {@link ParameterizedCompletion.Parameter}s.
* @see #getAttribute(int)
* @see #getAttributeCount()
*/
public Listnull.
* @see #setDescription(String)
*/
public String getDescription() {
return desc;
}
/**
* Returns the name of this tag.
*
* @return The name of this tag.
*/
public String getName() {
return name;
}
/**
* {@inheritDoc}
*/
public String getReplacementText() {
return getName();
}
/**
* {@inheritDoc}
*/
public String getSummary() {
StringBuilder sb = new StringBuilder();
addDefinitionString(sb);
possiblyAddDescription(sb);
addAttributes(sb);
possiblyAddDefinedIn(sb);
return sb.toString();
}
/**
* Adds some HTML describing where this variable is defined, if this
* information is known.
*
* @param sb The buffer to append to.
*/
protected void possiblyAddDefinedIn(StringBuilder sb) {
if (definedIn!=null) {
sb.append("
Defined in:"); // TODO: Localize me
sb.append(" ").append(definedIn).append("");
}
}
/**
* Adds the description text as HTML to a buffer, if a description is
* defined.
*
* @param sb The buffer to append to.
*/
protected void possiblyAddDescription(StringBuilder sb) {
if (desc!=null) {
sb.append("
");
sb.append(desc);
sb.append("
");
}
}
/**
* Sets where this variable is defined.
*
* @param definedIn Where this variable is defined.
* @see #getDefinedIn()
*/
public void setDefinedIn(String definedIn) {
this.definedIn = definedIn;
}
/**
* Sets the short description of this tag. This should be an
* HTML snippet.
*
* @param desc A short description of this tag. This may be
* null.
* @see #getDescription()
*/
public void setDescription(String desc) {
this.desc = desc;
}
/**
* Sets the attributes of this tag.
*
* @param attrs The attributes.
* @see #getAttribute(int)
* @see #getAttributeCount()
*/
public void setAttributes(List attrs) {
// Deep copy so parsing can re-use its array.
this.attrs = new ArrayListnull.
*/
public OutlineHighlightPainter(Color color) {
super(color);
setColor(color);
}
/**
* Returns the color to paint bounding boxes with.
*
* @return The color.
* @see #setColor(Color)
*/
@Override
public Color getColor() {
return color;
}
/**
* {@inheritDoc}
*/
@Override
public Shape paintLayer(Graphics g, int p0, int p1, Shape viewBounds,
JTextComponent c, View view) {
g.setColor(getColor());
p0++; // Workaround for Java Highlight issues.
// This special case isn't needed for most standard Swing Views (which
// always return a width of 1 for modelToView() calls), but it is
// needed for RSTA views, which actually return the width of chars for
// modelToView calls. But this should be faster anyway, as we
// short-circuit and do only one modelToView() for one offset.
if (p0==p1) {
try {
Shape s = view.modelToView(p0, viewBounds,
Position.Bias.Forward);
Rectangle r = s.getBounds();
g.drawLine(r.x, r.y, r.x, r.y+r.height);
return r;
} catch (BadLocationException ble) {
ble.printStackTrace(); // Never happens
return null;
}
}
if (p0 == view.getStartOffset() && p1 == view.getEndOffset()) {
// Contained in view, can just use bounds.
Rectangle alloc;
if (viewBounds instanceof Rectangle) {
alloc = (Rectangle) viewBounds;
} else {
alloc = viewBounds.getBounds();
}
g.drawRect(alloc.x, alloc.y, alloc.width - 1, alloc.height - 1);
return alloc;
}
// Should only render part of View.
try {
// --- determine locations ---
Shape shape = view.modelToView(p0, Position.Bias.Forward, p1,
Position.Bias.Backward, viewBounds);
Rectangle r = (shape instanceof Rectangle) ? (Rectangle) shape
: shape.getBounds();
g.drawRect(r.x, r.y, r.width - 1, r.height - 1);
return r;
} catch (BadLocationException e) { // Never happens
e.printStackTrace();
return null;
}
}
/**
* Sets the color to paint the bounding boxes with.
*
* @param color The new color. This cannot be null.
* @see #getColor()
*/
public void setColor(Color color) {
if (color==null) {
throw new IllegalArgumentException("color cannot be null");
}
this.color = color;
}
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/ParameterChoicesProvider.java 0000664 0000000 0000000 00000002247 12207001023 0027410 0 ustar 00root root 0000000 0000000 /*
* 12/14/2010
*
* ParameterChoicesProvider.java - Provides completions for a
* ParameterizedCompletion's parameters.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import java.util.List;
import javax.swing.text.JTextComponent;
/**
* Provides completions for a {@link ParameterizedCompletion}'s parameters.
* So, for example, if the user code-completes a function or method, if
* a ParameterChoicesProvider is installed, it can return possible
* completions for the parameters to that function or method.
*
* @author Robert Futrell
* @version 1.0
*/
public interface ParameterChoicesProvider {
/**
* Returns a list of choices for a specific parameter.
*
* @param tc The text component.
* @param param The currently focused parameter.
* @return The list of parameters. This may be null for
* "no parameters," but might also be an empty list.
*/
public Listprintf" function, this would return
* "int printf(const char *, ...)".
*
* @return The definition string.
*/
public String getDefinitionString();
/**
* Returns the specified {@link Parameter}.
*
* @param index The index of the parameter to retrieve.
* @return The parameter.
* @see #getParamCount()
*/
public Parameter getParam(int index);
/**
* Returns the number of parameters this completion takes.
*
* @return The number of parameters this completion takes.
* @see #getParam(int)
*/
public int getParamCount();
public ParameterizedCompletionInsertionInfo getInsertionInfo(
JTextComponent tc, boolean replaceTabsWithSpaces);
/**
* Returns whether a tool tip displaying assistance for each parameter
* while it is being edited is appropriate for this completion.
*
* @return Whether the tool tip is appropriate to display.
*/
public boolean getShowParameterToolTip();
/**
* A parameter passed to a parameterized {@link Completion}.
*/
public static class Parameter {
private String name;
private Object type;
private String desc;
private boolean isEndParam;
/**
* Constructor.
*
* @param type The type of this parameter. This may be
* null for languages without specific types,
* dynamic typing, etc. Usually you'll pass a String for this
* value, but you may pass any object representing a type in
* your language, as long as its toString() method
* returns a string representation of the type.
* @param name The name of the parameter.
*/
public Parameter(Object type, String name) {
this(type, name, false);
}
/**
* Constructor.
*
* @param type The type of this parameter. This may be
* null for languages without specific types,
* dynamic typing, etc. Usually you'll pass a String for this
* value, but you may pass any object representing a type in
* your language, as long as its toString() method
* returns a string representation of the type.
* @param name The name of the parameter.
* @param endParam Whether this parameter is an "ending parameter;"
* that is, whether this parameter is at a logical "ending
* point" in the completion text. If the user types in a
* parameter that is an ending point, parameter completion mode
* terminates. Set this to true for a trailing
* parameter after a function call's closing ')', for example.
*/
public Parameter(Object type, String name, boolean endParam) {
this.name = name;
this.type = type;
this.isEndParam = endParam;
}
public String getDescription() {
return desc;
}
public String getName() {
return name;
}
/**
* Returns the type of this parameter, as a string.
*
* @return The type of the parameter, or null for none.
*/
public String getType() {
return type==null ? null : type.toString();
}
/**
* Returns the object used to describe the type of this parameter.
*
* @return The type object, or null for none.
*/
public Object getTypeObject() {
return type;
}
/**
* @return Whether this parameter is an "ending parameter;"
* that is, whether this parameter is at a logical "ending
* point" in the completion text. If the user types in a
* parameter that is an ending point, parameter completion mode
* terminates.
*/
public boolean isEndParam() {
return isEndParam;
}
public void setDescription(String desc) {
this.desc = desc;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
if (getType()!=null) {
sb.append(getType());
}
if (getName()!=null) {
if (getType()!=null) {
sb.append(' ');
}
sb.append(getName());
}
return sb.toString();
}
}
} autocomplete-2.5.0/src/org/fife/ui/autocomplete/ParameterizedCompletionChoicesWindow.java 0000664 0000000 0000000 00000020470 12207001023 0031771 0 ustar 00root root 0000000 0000000 /*
* 12/11/2010
*
* ParameterizedCompletionChoicesWindow.java - A list of likely choices for a
* parameter.
*
* This library is distributed under a modified BSD license. See the included
* RSyntaxTextArea.License.txt file for details.
*/
package org.fife.ui.autocomplete;
import java.awt.ComponentOrientation;
import java.awt.Dimension;
import java.awt.Rectangle;
import java.awt.Window;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.swing.DefaultListModel;
import javax.swing.JList;
import javax.swing.JScrollPane;
import javax.swing.JWindow;
import javax.swing.SwingUtilities;
import javax.swing.text.JTextComponent;
import org.fife.ui.rsyntaxtextarea.PopupWindowDecorator;
/**
* A small popup window offering a list of likely choices for a parameter
* when the user has code-completed a parameterized completion. For example,
* if they have just code-completed the C function "fprintf",
* when entering the file name, this popup might display all local variables
* of type "char *".
*
* @author Robert Futrell
* @version 1.0
*/
public class ParameterizedCompletionChoicesWindow extends JWindow {
/**
* The parent AutoCompletion instance.
*/
private AutoCompletion ac;
/**
* The list of completion choices.
*/
private JList list;
/**
* The currently displayed completion choices.
*/
private DefaultListModel model;
/**
* A list of lists of choices for each parameter.
*/
private Listnull if nothing is
* selected.
*/
public String getSelectedChoice() {
Completion c = (Completion)list.getSelectedValue();
return c==null ? null : c.toString();
}
/**
* Changes the selected index.
*
* @param amount The amount by which to change the selected index.
*/
public void incSelection(int amount) {
int selection = list.getSelectedIndex();
selection += amount;
if (selection<0) {
// Account for nothing selected yet
selection = model.getSize()-1;//+= model.getSize();
}
else {
selection %= model.getSize();
}
list.setSelectedIndex(selection);
list.ensureIndexIsVisible(selection);
}
/**
* Initializes this window to offer suggestions for the parameters of
* a specific completion.
*
* @param pc The completion whose parameters we should offer suggestions
* for.
*/
public void initialize(ParameterizedCompletion pc) {
CompletionProvider provider = pc.getProvider();
ParameterChoicesProvider pcp = provider.getParameterChoicesProvider();
if (pcp==null) {
choicesListList = null;
return;
}
int paramCount = pc.getParamCount();
choicesListList = new ArrayList-1 if not in a parameter (i.e., on
* the comma between parameters).
* @param prefix Text in the parameter before the dot. This may
* be null to represent the empty string.
*/
public void setParameter(int param, String prefix) {
model.clear();
List