Attachment #26713 for bug #68235

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 68235
Collapse All | Expand All

Lines 176-181 Link Here

(-)editor/codetemplates/src/org/netbeans/lib/editor/codetemplates/CodeTemplateCompletionItem.java (+9 lines)
176	return "";	176	return "";
177	}	177	}
178		178
		179	public CharSequence getInsertPrefix() {
		180	String insertPrefix = codeTemplate.getParametrizedText();
		181	int dollarIndex = insertPrefix.indexOf("${");
		182	if (dollarIndex >= 0) {
		183	insertPrefix = insertPrefix.substring(0, dollarIndex);
		184	}
		185	return insertPrefix;
		186	}
		187
179	private static final class DocQuery extends AsyncCompletionQuery {	188	private static final class DocQuery extends AsyncCompletionQuery {
180		189
181	private CodeTemplate codeTemplate;	190	private CodeTemplate codeTemplate;





        <change>
            <api name="completion"/>
            <summary>Addition of CompletionResultSet.setWaitText()</summary>
            <version major="1" minor="5"/>
            <date day="8" month="11" year="2005"/>
            <author login="mmetelka"/>
            <compatibility addition="yes"/>
            <description>
            <p>
                <code>void CompletionResultSet.setWaitText(String waitText)</code> was added
                to allow customization of the text in the label displayed
                if the completion query results are not computed in certain timeout.
            </p>
            </description>
            <issue number="68235"/>
        </change>

        <change>
            <api name="completion"/>
            <summary>Adddition of CompletionItem.getInsertPrefix()</summary>
            <version major="1" minor="4"/>
            <date day="8" month="11" year="2005"/>
            <author login="mmetelka"/>
            <compatibility addition="no"/>
            <description>
            <p>
                <code>CharSequence CompletionItem.getInsertPrefix()</code> was added.
            </p>
            </description>
            <issue number="68235"/>
        </change>

        <change>
            <api name="completion"/>
            <summary>Semantic change of CompletionTask.refresh()</summary>
            <version major="1" minor="3"/>
            <date day="8" month="11" year="2005"/>
            <author login="mmetelka"/>
            <compatibility addition="no"/>
            <description>
            <p>
                CompletionTask.refresh(CompletionResultSet resultSet) now allows
                <code>null</code> parameter.
                <br/>
                <code>void AsyncCompletionQuery.preQueryUpdate(JTextComponent component)</code>
                was added to reflect that in AsyncCompletionTask.
            </p>
            </description>
            <issue number="68235"/>
        </change>

        <change>
            <api name="completion"/>
            <summary>Editor Code Completion API created</summary>
            <version major="1" minor="1"/>
            <date day="27" month="7" year="2005"/>

            </description>
            <issue number="59388"/>
        </change>

    </changes>

    <!-- Now the surrounding HTML text and document structure: -->

Lines 2-5 Link Here

(-)editor/completion/manifest.mf (-1 / +1 lines)
2	OpenIDE-Module: org.netbeans.modules.editor.completion/1	2	OpenIDE-Module: org.netbeans.modules.editor.completion/1
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/editor/completion/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/editor/completion/Bundle.properties
4	OpenIDE-Module-Install: org/netbeans/modules/editor/completion/CompletionModule.class	4	OpenIDE-Module-Install: org/netbeans/modules/editor/completion/CompletionModule.class
5	OpenIDE-Module-Specification-Version: 1.2	5	OpenIDE-Module-Specification-Version: 1.5




        Registry.addChangeListener(this);
        completionAutoPopupTimer = new Timer(0, new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                queryResultSets(completionResult.getResultSets());
                completionResult.queryInvoked();
            }
        });
        completionAutoPopupTimer.setRepeats(false);

                    }
                    if (completionResultNull && (type & CompletionProvider.COMPLETION_QUERY_TYPE) != 0 &&
                            CompletionSettings.INSTANCE.completionAutoPopup()) {
                        showCompletion(false, true);
                    }

                    boolean tooltipResultNull;

	}
    }
    
    void completionQuery(boolean delayQuery) {
        pleaseWaitTimer.restart();
        refreshedQuery = false;
        

        }
        
        // Query the tasks
        if (delayQuery) {
            restartCompletionAutoPopupTimer();
        } else {
            queryResultSets(completionResultSets);
            newCompletionResult.queryInvoked();
        }
    }

    /**

     * May be called from any thread but it will be rescheduled into AWT.
     */
    public void showCompletion() {
        showCompletion(false, false);
    }
    
    private void showCompletion(boolean explicitQuery, boolean delayQuery) {
        if (!SwingUtilities.isEventDispatchThread()) {
            // Re-call this method in AWT if necessary
            SwingUtilities.invokeLater(new ParamRunnable(ParamRunnable.SHOW_COMPLETION));

        this.explicitQuery = explicitQuery;
        if (activeProviders != null) {
            completionCancel(); // cancel possibly pending query
            completionQuery(delayQuery);
        }
    }



    private final class CompletionShowAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
            showCompletion(true, false);
        }
    }


        }
    }
    
    private static void refreshResultSets(List resultSets, boolean beforeQuery) {
        int size = resultSets.size();
        for (int i = 0; i < size; i++) {
            CompletionResultSetImpl result = (CompletionResultSetImpl)resultSets.get(i);
            result.getTask().refresh(beforeQuery ? null : result.getResultSet());
        }
    }
    

        
        private final List/*<CompletionResultSetImpl>*/ resultSets;
        
        private boolean invoked;                
        
        private boolean cancelled;
        private boolean beforeQuery = true;
        
        Result(int resultSetsSize) {
            resultSets = new ArrayList(resultSetsSize);

                assert (!invoked);
                invoked = true;
                canc = cancelled;
                beforeQuery = false;
            }
            if (canc) {
                cancelResultSets(resultSets);

                if (cancelled) {
                    return null;
                }
                if (beforeQuery) {
                    return this;
                }
                assert (invoked); // had to be invoked
                invoked = false;
            }
            Result refreshResult = new Result(getResultSets().size());
            refreshResult.beforeQuery = beforeQuery;
            createRefreshResultSets(resultSets, refreshResult);
            return refreshResult;
        }

         * {@link #createRefreshResult()}.
         */
        void invokeRefresh() {
            refreshResultSets(getResultSets(), beforeQuery);
            if (!beforeQuery)
                queryInvoked();
        }

    }

Lines 235-238 Link Here

(-)editor/completion/src/org/netbeans/modules/editor/completion/CompletionResultSetImpl.java (+4 lines)
235	}	235	}
236	}	236	}
237		237
		238	public void setWaitText(String waitText) {
		239	throw new UnsupportedOperationException("Not yet implemented");
		240	}
		241
238	}	242	}




    /**
     * Returns a text used to sort items alphabetically.
     */
    CharSequence getSortText();

    /**
     * Returns a text used for finding of a longest common prefix
     * after the <i>TAB</i> gets pressed or when the completion is opened explicitly.
     * <br>
     * The completion infrastructure will evaluate the insert prefixes
     * of all the items present in the visible result and finds the longest
     * common prefix.
     *
     * <p>
     * Generally the returned text does not need to contain all the information
     * that gets inserted when the item is selected.
     * <br>
     * For example in java completion the field name should be returned for fields
     * or a method name for methods (but not parameters)
     * or a non-FQN name for classes.
     *
     * @return non-null character sequence containing the insert prefix.
     *  <br>
     *  Returning an empty string will effectively disable the TAB completion
     *  as the longest common prefix will be empty.
     *
     * @since 1.4
     */
    CharSequence getInsertPrefix();

}




    public int getSortType() {
        return impl.getSortType();
    }
    
    /**
     * Set the explicit value displayed in a label when the completion results
     * do not get computed during a certain timeout (e.g. 250ms).
     * <br>
     * If not set explicitly the completion infrastructure will use
     * the default text.
     *
     * @param waitText description of what the query copmutation
     *  is currently (doing or waiting for).
     *  <br>
     *  After previous explicit setting <code>null</code> can be passed
     *  to restore using of the default text.
     *  
     * @since 1.5
     */
    public void setWaitText(String waitText) {
        impl.setWaitText(waitText);
    }

    
    private static final class SpiAccessor extends CompletionSpiPackageAccessor {

Lines 52-59 Link Here

(-)editor/completion/src/org/netbeans/spi/editor/completion/CompletionTask.java (-1 / +13 lines)
52	* <br>	52	* <br>
53	* This method can be called multiple times on a single task instance.	53	* This method can be called multiple times on a single task instance.
54	* <br>	54	* <br>
		55	* Typically it is called AFTER the <code>query()</code> was invoked
		56	* but it may also be invoked BEFORE the <code>query()</code> in case
		57	* the user types even before the <code>query()</code>
		58	* was called by the infrastructure. In such
		59	* case the <code>resultSet</code> parameter will be <code>null</code>.
		60	* <br>
55	* It is guaranteed that this method will not be invoked in case	61	* It is guaranteed that this method will not be invoked in case
56	* the document of the component would change since the last invocation	62	* the document instance set in the component would change since the last invocation
57	* of either the <code>query()</code> or <code>refresh()</code>.	63	* of either the <code>query()</code> or <code>refresh()</code>.
58	*	64	*
59	* <p>	65	* <p>
Lines 63-68 Link Here
63	*	69	*
64	* @param resultSet non-null result set to which the results	70	* @param resultSet non-null result set to which the results
65	* of the refreshing must be added.	71	* of the refreshing must be added.
		72	* <br/>
		73	* Null result set may be passed in case the <code>query()</code>
		74	* was not invoked yet and user has typed a character. In this case
		75	* the provider may hide the completion
		76	* by using <code>Completion.get().hideAll()</code>
		77	* if the typed character is inappropriate e.g. ";" for java completion.
66	*/	78	*/
67	public void refresh(CompletionResultSet resultSet);	79	public void refresh(CompletionResultSet resultSet);
68		80




public abstract class AsyncCompletionQuery {
    
    private AsyncCompletionTask task;

    /**
     * Called in response to <code>CompletionTask.refresh(null)</code>.
     * <br/>
     * The method gets invoked once the the user types a character
     * but the <code>CompletionTask.query()</code> was not yet invoked.
     * <br/>
     * The method may want to inspect the typed character before the caret
     * position and decide whether the completion should be hidden
     * if the typed character is inappropriate e.g. ";" for java completion.
     *
     * @since 1.3
     */
    protected void preQueryUpdate(JTextComponent component) {        
        // Always done in AWT thread - by default do nothing
    }
    
    /**
     * Perform the query and add results to the given result set.

Lines 51-56 Link Here

(-)editor/completion/src/org/netbeans/spi/editor/completion/support/AsyncCompletionTask.java (-3 / +11 lines)
51		51
52	/** Whether this task is cancelled. */	52	/** Whether this task is cancelled. */
53	private boolean cancelled;	53	private boolean cancelled;
		54
		55	/** Whether query was already invoked on this task. */
		56	private boolean queryInvoked;
54		57
55	/**	58	/**
56	* Construct asynchronous task for the given component.	59	* Construct asynchronous task for the given component.
Lines 89-94 Link Here
89	} else {	92	} else {
90	doc = null;	93	doc = null;
91	}	94	}
		95	queryInvoked = true;
92		96
93	synchronized (this) {	97	synchronized (this) {
94	performQuery(resultSet);	98	performQuery(resultSet);
Lines 103-113 Link Here
103	* The results should be fired into the newly provided completion listener.	107	* The results should be fired into the newly provided completion listener.
104	*/	108	*/
105	public void refresh(CompletionResultSet resultSet) {	109	public void refresh(CompletionResultSet resultSet) {
106	assert (resultSet != null);
107	assert (SwingUtilities.isEventDispatchThread());	110	assert (SwingUtilities.isEventDispatchThread());
108	assert !cancelled : "refresh() called on canceled task"; // NOI18N	111	assert !cancelled : "refresh() called on canceled task"; // NOI18N
109	refreshResultSet = resultSet;	112	if (queryInvoked) {
110	refreshImpl();	113	assert (resultSet != null);
		114	refreshResultSet = resultSet;
		115	refreshImpl();
		116	} else {
		117	query.preQueryUpdate(component);
		118	}
111	}	119	}
112		120
113	/**	121	/**

Lines 350-355 Link Here

(-)java/editor/src/org/netbeans/modules/editor/java/ElementCreatingCompletionProvider.java (+9 lines)
350	return 300;	350	return 300;
351	}	351	}
352		352
		353	public CharSequence getInsertPrefix() {
		354	return getItemText();
		355	}
		356
353	public void create(int offset) {	357	public void create(int offset) {
354	BaseDocument bdoc = (BaseDocument) document;	358	BaseDocument bdoc = (BaseDocument) document;
355	Position position = null;	359	Position position = null;
Lines 615-620 Link Here
615	public int getSortPriority() {	619	public int getSortPriority() {
616	return isImplement ? 0 : 500;	620	return isImplement ? 0 : 500;
617	}	621	}
		622
		623	public CharSequence getInsertPrefix() {
		624	return getItemText();
		625	}
		626
618	}	627	}
619		628
620	private static class NbOverrideMethodPaintComponent extends NbJMIPaintComponent.NbMethodPaintComponent {	629	private static class NbOverrideMethodPaintComponent extends NbJMIPaintComponent.NbMethodPaintComponent {




    
    public CompletionTask createTask(int queryType, JTextComponent component) {
        if (queryType == COMPLETION_QUERY_TYPE)
            return new AsyncCompletionTask(new Query(component.getCaret().getDot()), component);
        else if (queryType == DOCUMENTATION_QUERY_TYPE)
            return new AsyncCompletionTask(new DocQuery(null), component);
        else if (queryType == TOOLTIP_QUERY_TYPE)

        
        private NbJavaJMICompletionQuery.JavaResult queryResult;
        
        private int creationCaretOffset;
        private int queryCaretOffset;
        
        private int queryAnchorOffset;
        
        private String filterPrefix;
        
        Query(int caretOffset) {
            this.creationCaretOffset = caretOffset;
        }
        
        protected void preQueryUpdate(JTextComponent component) {
            int caretOffset = component.getCaretPosition();
            Document doc = component.getDocument();
            if (caretOffset >= creationCaretOffset) {
                try {
                    if (isJavaIdentifierPart(doc.getText(creationCaretOffset, caretOffset - creationCaretOffset)))
                        return;
                } catch (BadLocationException e) {
                }
            }
            Completion.get().hideCompletion();
        }        
        
        protected void query(CompletionResultSet resultSet, Document doc, int caretOffset) {
            NbJavaJMICompletionQuery query = new NbJavaJMICompletionQuery(true);

Lines 176-181 Link Here

(-)java/editor/src/org/netbeans/modules/editor/java/NbJMIResultItem.java (+4 lines)
176	public CharSequence getSortText() {	176	public CharSequence getSortText() {
177	return getItemText();	177	return getItemText();
178	}	178	}
		179
		180	public CharSequence getInsertPrefix() {
		181	return getItemText();
		182	}
179		183
180	public CompletionTask createDocumentationTask() {	184	public CompletionTask createDocumentationTask() {
181	return new AsyncCompletionTask(new JavaCompletionProvider.DocQuery(this),	185	return new AsyncCompletionTask(new JavaCompletionProvider.DocQuery(this),

Lines 457-462 Link Here

(-)html/editor/lib/src/org/netbeans/editor/ext/html/HTMLCompletionQuery.java (+4 lines)
457	return HTMLResultItem.this.getItemText();	457	return HTMLResultItem.this.getItemText();
458	}	458	}
459		459
		460	public CharSequence getInsertPrefix() {
		461	return getItemText();
		462	}
		463
460	public Component getPaintComponent(boolean isSelected) {	464	public Component getPaintComponent(boolean isSelected) {
461	//TODO: the paint component should be caches somehow	465	//TODO: the paint component should be caches somehow
462	HTMLCompletionResultItemPaintComponent component = new HTMLCompletionResultItemPaintComponent.StringPaintComponent(getPaintColor());	466	HTMLCompletionResultItemPaintComponent component = new HTMLCompletionResultItemPaintComponent.StringPaintComponent(getPaintColor());

Lines 76-81 Link Here

(-)web/jspsyntax/src/org/netbeans/modules/web/core/syntax/completion/JspCompletionItem.java (+4 lines)
76	return DEFAULT_SORT_PRIORITY;	76	return DEFAULT_SORT_PRIORITY;
77	}	77	}
78		78
		79	public CharSequence getInsertPrefix() {
		80	return getItemText();
		81	}
		82
79	public Component getPaintComponent(boolean isSelected) {	83	public Component getPaintComponent(boolean isSelected) {
80	if (component == null) {	84	if (component == null) {
81	component = new ResultItemPaintComponent.StringPaintComponent();	85	component = new ResultItemPaintComponent.StringPaintComponent();

Return to bug 68235

Lines 148-154 Link Here

(-)editor/completion/src/org/netbeans/modules/editor/completion/CompletionImpl.java (-15 / +26 lines)
148	Registry.addChangeListener(this);	148	Registry.addChangeListener(this);
149	completionAutoPopupTimer = new Timer(0, new ActionListener() {	149	completionAutoPopupTimer = new Timer(0, new ActionListener() {
150	public void actionPerformed(ActionEvent e) {	150	public void actionPerformed(ActionEvent e) {
151	showCompletion();	151	queryResultSets(completionResult.getResultSets());
		152	completionResult.queryInvoked();
152	}	153	}
153	});	154	});
154	completionAutoPopupTimer.setRepeats(false);	155	completionAutoPopupTimer.setRepeats(false);
Lines 207-213 Link Here
207	}	208	}
208	if (completionResultNull && (type & CompletionProvider.COMPLETION_QUERY_TYPE) != 0 &&	209	if (completionResultNull && (type & CompletionProvider.COMPLETION_QUERY_TYPE) != 0 &&
209	CompletionSettings.INSTANCE.completionAutoPopup()) {	210	CompletionSettings.INSTANCE.completionAutoPopup()) {
210	restartCompletionAutoPopupTimer();	211	showCompletion(false, true);
211	}	212	}
212		213
213	boolean tooltipResultNull;	214	boolean tooltipResultNull;
Lines 448-454 Link Here
448	}	449	}
449	}	450	}
450		451
451	void completionQuery() {	452	void completionQuery(boolean delayQuery) {
452	pleaseWaitTimer.restart();	453	pleaseWaitTimer.restart();
453	refreshedQuery = false;	454	refreshedQuery = false;
454		455
Lines 471-478 Link Here
471	}	472	}
472		473
473	// Query the tasks	474	// Query the tasks
474	queryResultSets(completionResultSets);	475	if (delayQuery) {
475	newCompletionResult.queryInvoked();	476	restartCompletionAutoPopupTimer();
		477	} else {
		478	queryResultSets(completionResultSets);
		479	newCompletionResult.queryInvoked();
		480	}
476	}	481	}
477		482
478	/**	483	/**
Lines 510-519 Link Here
510	* May be called from any thread but it will be rescheduled into AWT.	515	* May be called from any thread but it will be rescheduled into AWT.
511	*/	516	*/
512	public void showCompletion() {	517	public void showCompletion() {
513	showCompletion(false);	518	showCompletion(false, false);
514	}	519	}
515		520
516	private void showCompletion(boolean explicitQuery) {	521	private void showCompletion(boolean explicitQuery, boolean delayQuery) {
517	if (!SwingUtilities.isEventDispatchThread()) {	522	if (!SwingUtilities.isEventDispatchThread()) {
518	// Re-call this method in AWT if necessary	523	// Re-call this method in AWT if necessary
519	SwingUtilities.invokeLater(new ParamRunnable(ParamRunnable.SHOW_COMPLETION));	524	SwingUtilities.invokeLater(new ParamRunnable(ParamRunnable.SHOW_COMPLETION));
Lines 523-529 Link Here
523	this.explicitQuery = explicitQuery;	528	this.explicitQuery = explicitQuery;
524	if (activeProviders != null) {	529	if (activeProviders != null) {
525	completionCancel(); // cancel possibly pending query	530	completionCancel(); // cancel possibly pending query
526	completionQuery();	531	completionQuery(delayQuery);
527	}	532	}
528	}	533	}
529		534
Lines 1042-1048 Link Here
1042		1047
1043	private final class CompletionShowAction extends AbstractAction {	1048	private final class CompletionShowAction extends AbstractAction {
1044	public void actionPerformed(ActionEvent e) {	1049	public void actionPerformed(ActionEvent e) {
1045	showCompletion(true);	1050	showCompletion(true, false);
1046	}	1051	}
1047	}	1052	}
1048		1053
Lines 1125-1135 Link Here
1125	}	1130	}
1126	}	1131	}
1127		1132
1128	private static void refreshResultSets(List resultSets) {	1133	private static void refreshResultSets(List resultSets, boolean beforeQuery) {
1129	int size = resultSets.size();	1134	int size = resultSets.size();
1130	for (int i = 0; i < size; i++) {	1135	for (int i = 0; i < size; i++) {
1131	CompletionResultSetImpl result = (CompletionResultSetImpl)resultSets.get(i);	1136	CompletionResultSetImpl result = (CompletionResultSetImpl)resultSets.get(i);
1132	result.getTask().refresh(result.getResultSet());	1137	result.getTask().refresh(beforeQuery ? null : result.getResultSet());
1133	}	1138	}
1134	}	1139	}
1135		1140
Lines 1171-1179 Link Here
1171		1176
1172	private final List/<CompletionResultSetImpl>/ resultSets;	1177	private final List/<CompletionResultSetImpl>/ resultSets;
1173		1178
1174	private boolean invoked;	1179	private boolean invoked;
1175
1176	private boolean cancelled;	1180	private boolean cancelled;
		1181	private boolean beforeQuery = true;
1177		1182
1178	Result(int resultSetsSize) {	1183	Result(int resultSetsSize) {
1179	resultSets = new ArrayList(resultSetsSize);	1184	resultSets = new ArrayList(resultSetsSize);
Lines 1221-1226 Link Here
1221	assert (!invoked);	1226	assert (!invoked);
1222	invoked = true;	1227	invoked = true;
1223	canc = cancelled;	1228	canc = cancelled;
		1229	beforeQuery = false;
1224	}	1230	}
1225	if (canc) {	1231	if (canc) {
1226	cancelResultSets(resultSets);	1232	cancelResultSets(resultSets);
Lines 1237-1246 Link Here
1237	if (cancelled) {	1243	if (cancelled) {
1238	return null;	1244	return null;
1239	}	1245	}
		1246	if (beforeQuery) {
		1247	return this;
		1248	}
1240	assert (invoked); // had to be invoked	1249	assert (invoked); // had to be invoked
1241	invoked = false;	1250	invoked = false;
1242	}	1251	}
1243	Result refreshResult = new Result(getResultSets().size());	1252	Result refreshResult = new Result(getResultSets().size());
		1253	refreshResult.beforeQuery = beforeQuery;
1244	createRefreshResultSets(resultSets, refreshResult);	1254	createRefreshResultSets(resultSets, refreshResult);
1245	return refreshResult;	1255	return refreshResult;
1246	}	1256	}
Lines 1251-1258 Link Here
1251	* {@link #createRefreshResult()}.	1261	* {@link #createRefreshResult()}.
1252	*/	1262	*/
1253	void invokeRefresh() {	1263	void invokeRefresh() {
1254	refreshResultSets(getResultSets());	1264	refreshResultSets(getResultSets(), beforeQuery);
1255	queryInvoked();	1265	if (!beforeQuery)
		1266	queryInvoked();
1256	}	1267	}
1257		1268
1258	}	1269	}

Lines 120-125 Link Here

(-)editor/completion/src/org/netbeans/spi/editor/completion/CompletionItem.java (-1 / +26 lines)
120	/**	120	/**
121	* Returns a text used to sort items alphabetically.	121	* Returns a text used to sort items alphabetically.
122	*/	122	*/
123	CharSequence getSortText();	123	CharSequence getSortText();
		124
		125	/**
		126	* Returns a text used for finding of a longest common prefix
		127	* after the <i>TAB</i> gets pressed or when the completion is opened explicitly.
		128	* <br>
		129	* The completion infrastructure will evaluate the insert prefixes
		130	* of all the items present in the visible result and finds the longest
		131	* common prefix.
		132	*
		133	* <p>
		134	* Generally the returned text does not need to contain all the information
		135	* that gets inserted when the item is selected.
		136	* <br>
		137	* For example in java completion the field name should be returned for fields
		138	* or a method name for methods (but not parameters)
		139	* or a non-FQN name for classes.
		140	*
		141	* @return non-null character sequence containing the insert prefix.
		142	* <br>
		143	* Returning an empty string will effectively disable the TAB completion
		144	* as the longest common prefix will be empty.
		145	*
		146	* @since 1.4
		147	*/
		148	CharSequence getInsertPrefix();
124		149
125	}	150	}

Lines 202-207 Link Here

(-)editor/completion/src/org/netbeans/spi/editor/completion/CompletionResultSet.java (+19 lines)
202	public int getSortType() {	202	public int getSortType() {
203	return impl.getSortType();	203	return impl.getSortType();
204	}	204	}
		205
		206	/**
		207	* Set the explicit value displayed in a label when the completion results
		208	* do not get computed during a certain timeout (e.g. 250ms).
		209	* <br>
		210	* If not set explicitly the completion infrastructure will use
		211	* the default text.
		212	*
		213	* @param waitText description of what the query copmutation
		214	* is currently (doing or waiting for).
		215	* <br>
		216	* After previous explicit setting <code>null</code> can be passed
		217	* to restore using of the default text.
		218	*
		219	* @since 1.5
		220	*/
		221	public void setWaitText(String waitText) {
		222	impl.setWaitText(waitText);
		223	}
205		224
206		225
207	private static final class SpiAccessor extends CompletionSpiPackageAccessor {	226	private static final class SpiAccessor extends CompletionSpiPackageAccessor {

Lines 79-84 Link Here

(-)editor/completion/apichanges.xml (+52 lines)
79		79
80	<change>	80	<change>
81	<api name="completion"/>	81	<api name="completion"/>
		82	<summary>Addition of CompletionResultSet.setWaitText()</summary>
		83	<version major="1" minor="5"/>
		84	<date day="8" month="11" year="2005"/>
		85	<author login="mmetelka"/>
		86	<compatibility addition="yes"/>
		87	<description>
		88	<p>
		89	<code>void CompletionResultSet.setWaitText(String waitText)</code> was added
		90	to allow customization of the text in the label displayed
		91	if the completion query results are not computed in certain timeout.
		92	</p>
		93	</description>
		94	<issue number="68235"/>
		95	</change>
		96
		97	<change>
		98	<api name="completion"/>
		99	<summary>Adddition of CompletionItem.getInsertPrefix()</summary>
		100	<version major="1" minor="4"/>
		101	<date day="8" month="11" year="2005"/>
		102	<author login="mmetelka"/>
		103	<compatibility addition="no"/>
		104	<description>
		105	<p>
		106	<code>CharSequence CompletionItem.getInsertPrefix()</code> was added.
		107	</p>
		108	</description>
		109	<issue number="68235"/>
		110	</change>
		111
		112	<change>
		113	<api name="completion"/>
		114	<summary>Semantic change of CompletionTask.refresh()</summary>
		115	<version major="1" minor="3"/>
		116	<date day="8" month="11" year="2005"/>
		117	<author login="mmetelka"/>
		118	<compatibility addition="no"/>
		119	<description>
		120	<p>
		121	CompletionTask.refresh(CompletionResultSet resultSet) now allows
		122	<code>null</code> parameter.
		123	<br/>
		124	<code>void AsyncCompletionQuery.preQueryUpdate(JTextComponent component)</code>
		125	was added to reflect that in AsyncCompletionTask.
		126	</p>
		127	</description>
		128	<issue number="68235"/>
		129	</change>
		130
		131	<change>
		132	<api name="completion"/>
82	<summary>Editor Code Completion API created</summary>	133	<summary>Editor Code Completion API created</summary>
83	<version major="1" minor="1"/>	134	<version major="1" minor="1"/>
84	<date day="27" month="7" year="2005"/>	135	<date day="27" month="7" year="2005"/>
Lines 91-96 Link Here
91	</description>	142	</description>
92	<issue number="59388"/>	143	<issue number="59388"/>
93	</change>	144	</change>
		145
94	</changes>	146	</changes>
95		147
96	<!-- Now the surrounding HTML text and document structure: -->	148	<!-- Now the surrounding HTML text and document structure: -->

Lines 34-39 Link Here

(-)editor/completion/src/org/netbeans/spi/editor/completion/support/AsyncCompletionQuery.java (+16 lines)
34	public abstract class AsyncCompletionQuery {	34	public abstract class AsyncCompletionQuery {
35		35
36	private AsyncCompletionTask task;	36	private AsyncCompletionTask task;
		37
		38	/**
		39	* Called in response to <code>CompletionTask.refresh(null)</code>.
		40	* <br/>
		41	* The method gets invoked once the the user types a character
		42	* but the <code>CompletionTask.query()</code> was not yet invoked.
		43	* <br/>
		44	* The method may want to inspect the typed character before the caret
		45	* position and decide whether the completion should be hidden
		46	* if the typed character is inappropriate e.g. ";" for java completion.
		47	*
		48	* @since 1.3
		49	*/
		50	protected void preQueryUpdate(JTextComponent component) {
		51	// Always done in AWT thread - by default do nothing
		52	}
37		53
38	/**	54	/**
39	* Perform the query and add results to the given result set.	55	* Perform the query and add results to the given result set.

Lines 58-64 Link Here

(-)java/editor/src/org/netbeans/modules/editor/java/JavaCompletionProvider.java (-1 / +19 lines)
58		58
59	public CompletionTask createTask(int queryType, JTextComponent component) {	59	public CompletionTask createTask(int queryType, JTextComponent component) {
60	if (queryType == COMPLETION_QUERY_TYPE)	60	if (queryType == COMPLETION_QUERY_TYPE)
61	return new AsyncCompletionTask(new Query(), component);	61	return new AsyncCompletionTask(new Query(component.getCaret().getDot()), component);
62	else if (queryType == DOCUMENTATION_QUERY_TYPE)	62	else if (queryType == DOCUMENTATION_QUERY_TYPE)
63	return new AsyncCompletionTask(new DocQuery(null), component);	63	return new AsyncCompletionTask(new DocQuery(null), component);
64	else if (queryType == TOOLTIP_QUERY_TYPE)	64	else if (queryType == TOOLTIP_QUERY_TYPE)
Lines 72-82 Link Here
72		72
73	private NbJavaJMICompletionQuery.JavaResult queryResult;	73	private NbJavaJMICompletionQuery.JavaResult queryResult;
74		74
		75	private int creationCaretOffset;
75	private int queryCaretOffset;	76	private int queryCaretOffset;
76		77
77	private int queryAnchorOffset;	78	private int queryAnchorOffset;
78		79
79	private String filterPrefix;	80	private String filterPrefix;
		81
		82	Query(int caretOffset) {
		83	this.creationCaretOffset = caretOffset;
		84	}
		85
		86	protected void preQueryUpdate(JTextComponent component) {
		87	int caretOffset = component.getCaretPosition();
		88	Document doc = component.getDocument();
		89	if (caretOffset >= creationCaretOffset) {
		90	try {
		91	if (isJavaIdentifierPart(doc.getText(creationCaretOffset, caretOffset - creationCaretOffset)))
		92	return;
		93	} catch (BadLocationException e) {
		94	}
		95	}
		96	Completion.get().hideCompletion();
		97	}
80		98
81	protected void query(CompletionResultSet resultSet, Document doc, int caretOffset) {	99	protected void query(CompletionResultSet resultSet, Document doc, int caretOffset) {
82	NbJavaJMICompletionQuery query = new NbJavaJMICompletionQuery(true);	100	NbJavaJMICompletionQuery query = new NbJavaJMICompletionQuery(true);