KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > jdt > internal > ui > refactoring > contentassist > JavaTypeCompletionProcessor


1 /*******************************************************************************
2  * Copyright (c) 2000, 2005 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Eclipse Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/epl-v10.html
7  *
8  * Contributors:
9  * IBM Corporation - initial API and implementation
10  *******************************************************************************/

11
12 package org.eclipse.jdt.internal.ui.refactoring.contentassist;
13
14 import java.util.Arrays JavaDoc;
15 import java.util.List JavaDoc;
16
17 import org.eclipse.jdt.core.CompletionProposal;
18 import org.eclipse.jdt.core.ICompilationUnit;
19 import org.eclipse.jdt.core.IJavaElement;
20 import org.eclipse.jdt.core.IPackageFragment;
21 import org.eclipse.jdt.core.IType;
22 import org.eclipse.jdt.core.Signature;
23
24 import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
25 import org.eclipse.jdt.internal.corext.util.TypeFilter;
26
27 import org.eclipse.jdt.internal.ui.JavaPluginImages;
28 import org.eclipse.jdt.internal.ui.viewsupport.JavaElementImageProvider;
29
30 public class JavaTypeCompletionProcessor extends CUPositionCompletionProcessor {
31     
32     public static final String JavaDoc DUMMY_CLASS_NAME= "$$__$$"; //$NON-NLS-1$
33

34     /**
35      * The CU name to be used if no parent ICompilationUnit is available.
36      * The main type of this class will be filtered out from the proposals list.
37      */

38     public static final String JavaDoc DUMMY_CU_NAME= DUMMY_CLASS_NAME + JavaModelUtil.DEFAULT_CU_SUFFIX;
39     
40     /**
41      * Creates a <code>JavaTypeCompletionProcessor</code>.
42      * The completion context must be set via {@link #setPackageFragment(IPackageFragment)}.
43      *
44      * @param enableBaseTypes complete java base types iff <code>true</code>
45      * @param enableVoid complete <code>void</code> base type iff <code>true</code>
46      */

47     public JavaTypeCompletionProcessor(boolean enableBaseTypes, boolean enableVoid) {
48         this(enableBaseTypes, enableVoid, false);
49     }
50     
51     /**
52      * Creates a <code>JavaTypeCompletionProcessor</code>.
53      * The completion context must be set via {@link #setPackageFragment(IPackageFragment)}.
54      *
55      * @param enableBaseTypes complete java base types iff <code>true</code>
56      * @param enableVoid complete <code>void</code> base type iff <code>true</code>
57      * @param fullyQualify always complete to fully qualifies type iff <code>true</code>
58      */

59     public JavaTypeCompletionProcessor(boolean enableBaseTypes, boolean enableVoid, boolean fullyQualify) {
60         super(new TypeCompletionRequestor(enableBaseTypes, enableVoid, fullyQualify));
61     }
62     
63     public char[] getCompletionProposalAutoActivationCharacters() {
64         // disable auto activation in dialog fields, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=89476
65
return null;
66     }
67
68     /**
69      * @param packageFragment the new completion context
70      */

71     public void setPackageFragment(IPackageFragment packageFragment) {
72         //TODO: Some callers have a better completion context and should include imports
73
// and nested classes of their declaring CU in WC's source.
74
if (packageFragment == null) {
75             setCompletionContext(null, null, null);
76         } else {
77             String JavaDoc before= "public class " + DUMMY_CLASS_NAME + " { "; //$NON-NLS-1$//$NON-NLS-2$
78
String JavaDoc after= " }"; //$NON-NLS-1$
79
setCompletionContext(packageFragment.getCompilationUnit(DUMMY_CU_NAME), before, after);
80         }
81     }
82     
83     public void setExtendsCompletionContext(IJavaElement javaElement) {
84         if (javaElement instanceof IPackageFragment) {
85             IPackageFragment packageFragment= (IPackageFragment) javaElement;
86             ICompilationUnit cu= packageFragment.getCompilationUnit(DUMMY_CU_NAME);
87             setCompletionContext(cu, "public class " + DUMMY_CLASS_NAME + " extends ", " {}"); //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
88
} else if (javaElement instanceof IType) {
89             // pattern: public class OuterType { public class Type extends /*caret*/ {} }
90
IType type= (IType) javaElement;
91             String JavaDoc before= "public class " + type.getElementName() + " extends "; //$NON-NLS-1$ //$NON-NLS-2$
92
String JavaDoc after= " {}"; //$NON-NLS-1$
93
IJavaElement parent= type.getParent();
94             while (parent instanceof IType) {
95                 type= (IType) parent;
96                 before+= "public class " + type.getElementName() + " {"; //$NON-NLS-1$ //$NON-NLS-2$
97
after+= "}"; //$NON-NLS-1$
98
parent= type.getParent();
99             }
100             ICompilationUnit cu= type.getCompilationUnit();
101             setCompletionContext(cu, before, after);
102         } else {
103             setCompletionContext(null, null, null);
104         }
105     }
106
107 // public void setImplementsCompletionContext(IPackageFragment packageFragment) {
108
// ICompilationUnit cu= packageFragment.getCompilationUnit(DUMMY_CU_NAME);
109
// setCompletionContext(cu, "public class " + DUMMY_CLASS_NAME + " implements ", " {}"); //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
110
// }
111

112     protected static class TypeCompletionRequestor extends CUPositionCompletionRequestor {
113         private static final String JavaDoc VOID= "void"; //$NON-NLS-1$
114
private static final List JavaDoc BASE_TYPES= Arrays.asList(
115             new String JavaDoc[] {"boolean", "byte", "char", "double", "float", "int", "long", "short"}); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$ //$NON-NLS-8$
116

117         private boolean fEnableBaseTypes;
118         private boolean fEnableVoid;
119         private final boolean fFullyQualify;
120         
121         public TypeCompletionRequestor(boolean enableBaseTypes, boolean enableVoid, boolean fullyQualify) {
122             fFullyQualify= fullyQualify;
123             fEnableBaseTypes= enableBaseTypes;
124             fEnableVoid= enableVoid;
125             setIgnored(CompletionProposal.ANONYMOUS_CLASS_DECLARATION, true);
126             setIgnored(CompletionProposal.FIELD_REF, true);
127             setIgnored(CompletionProposal.LABEL_REF, true);
128             setIgnored(CompletionProposal.LOCAL_VARIABLE_REF, true);
129             setIgnored(CompletionProposal.METHOD_DECLARATION, true);
130             setIgnored(CompletionProposal.METHOD_REF, true);
131             setIgnored(CompletionProposal.VARIABLE_DECLARATION, true);
132             setIgnored(CompletionProposal.POTENTIAL_METHOD_DECLARATION, true);
133             setIgnored(CompletionProposal.METHOD_NAME_REFERENCE, true);
134         }
135         
136         public void accept(CompletionProposal proposal) {
137             switch (proposal.getKind()) {
138                 case CompletionProposal.PACKAGE_REF :
139                     char[] packageName= proposal.getDeclarationSignature();
140                     if (TypeFilter.isFiltered(packageName))
141                         return;
142                     addAdjustedCompletion(
143                             new String JavaDoc(packageName),
144                             new String JavaDoc(proposal.getCompletion()),
145                             proposal.getReplaceStart(),
146                             proposal.getReplaceEnd(),
147                             proposal.getRelevance(),
148                             JavaPluginImages.DESC_OBJS_PACKAGE);
149                     return;
150                     
151                 case CompletionProposal.TYPE_REF :
152                     char[] fullName= Signature.toCharArray(proposal.getSignature());
153                     if (TypeFilter.isFiltered(fullName))
154                         return;
155                     StringBuffer JavaDoc buf= new StringBuffer JavaDoc();
156                     buf.append(Signature.getSimpleName(fullName));
157                     if (buf.length() == 0)
158                         return; // this is the dummy class, whose $ have been converted to dots
159
char[] typeQualifier= Signature.getQualifier(fullName);
160                     if (typeQualifier.length > 0) {
161                         buf.append(" - "); //$NON-NLS-1$
162
buf.append(typeQualifier);
163                     }
164                     String JavaDoc name= buf.toString();
165                     
166                     addAdjustedTypeCompletion(
167                             name,
168                             new String JavaDoc(proposal.getCompletion()),
169                             proposal.getReplaceStart(),
170                             proposal.getReplaceEnd(),
171                             proposal.getRelevance(),
172                             JavaElementImageProvider.getTypeImageDescriptor(false, false, proposal.getFlags(), false),
173                             fFullyQualify ? new String JavaDoc(fullName) : null);
174                     return;
175                     
176                 case CompletionProposal.KEYWORD:
177                     if (! fEnableBaseTypes)
178                         return;
179                     String JavaDoc keyword= new String JavaDoc(proposal.getName());
180                     if ( (fEnableVoid && VOID.equals(keyword)) || (fEnableBaseTypes && BASE_TYPES.contains(keyword)) )
181                         addAdjustedCompletion(
182                                 keyword,
183                                 new String JavaDoc(proposal.getCompletion()),
184                                 proposal.getReplaceStart(),
185                                 proposal.getReplaceEnd(),
186                                 proposal.getRelevance(),
187                                 null);
188                     return;
189
190                 default :
191                     return;
192             }
193             
194         }
195     }
196 }
197
Popular Tags