ColoredJavaElementLabels


1   /*******************************************************************************
2    * Copyright (c) 2000, 2007 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  package org.eclipse.jdt.internal.ui.viewsupport;
12  
13  import org.eclipse.core.runtime.IPath;
14  
15  import org.eclipse.core.resources.IProject;
16  import org.eclipse.core.resources.IResource;
17  
18  import org.eclipse.ui.model.IWorkbenchAdapter;
19  
20  import org.eclipse.jdt.core.BindingKey;
21  import org.eclipse.jdt.core.ClasspathContainerInitializer;
22  import org.eclipse.jdt.core.Flags;
23  import org.eclipse.jdt.core.IClassFile;
24  import org.eclipse.jdt.core.IClasspathContainer;
25  import org.eclipse.jdt.core.IClasspathEntry;
26  import org.eclipse.jdt.core.ICompilationUnit;
27  import org.eclipse.jdt.core.IField;
28  import org.eclipse.jdt.core.IInitializer;
29  import org.eclipse.jdt.core.IJavaElement;
30  import org.eclipse.jdt.core.IJavaProject;
31  import org.eclipse.jdt.core.ILocalVariable;
32  import org.eclipse.jdt.core.IMember;
33  import org.eclipse.jdt.core.IMethod;
34  import org.eclipse.jdt.core.IPackageFragment;
35  import org.eclipse.jdt.core.IPackageFragmentRoot;
36  import org.eclipse.jdt.core.IType;
37  import org.eclipse.jdt.core.ITypeParameter;
38  import org.eclipse.jdt.core.JavaCore;
39  import org.eclipse.jdt.core.JavaModelException;
40  import org.eclipse.jdt.core.Signature;
41  
42  import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
43  import org.eclipse.jdt.internal.corext.util.Messages;
44  
45  import org.eclipse.jdt.launching.JavaRuntime;
46  
47  import org.eclipse.jdt.ui.JavaElementLabels;
48  
49  import org.eclipse.jdt.internal.ui.JavaPlugin;
50  import org.eclipse.jdt.internal.ui.JavaUIMessages;
51  import org.eclipse.jdt.internal.ui.packageview.ClassPathContainer;
52  import org.eclipse.jdt.internal.ui.viewsupport.ColoredString.Style;
53  
54  public class ColoredJavaElementLabels {
55  
56      public static final Style QUALIFIER_STYLE= new Style(ColoredViewersManager.QUALIFIER_COLOR_NAME); 
57      public static final Style COUNTER_STYLE= new Style(ColoredViewersManager.COUNTER_COLOR_NAME); 
58      public static final Style DECORATIONS_STYLE= new Style(ColoredViewersManager.DECORATIONS_COLOR_NAME); 
59      
60      private static final Style APPENDED_TYPE_STYLE= DECORATIONS_STYLE; 
61      
62      public final static long COLORIZE= 1L << 55;
63      
64      private final static long QUALIFIER_FLAGS= JavaElementLabels.P_COMPRESSED | JavaElementLabels.USE_RESOLVED;
65      
66  
67      private static final boolean getFlag(long flags, long flag) {
68          return (flags & flag) != 0;
69      }
70      
71      /**
72       * Returns the label of the given object. The object must be of type {@link IJavaElement} or adapt to {@link IWorkbenchAdapter}. The empty string is returned
73       * if the element type is not known.
74       * @param obj Object to get the label from.
75       * @param flags The rendering flags
76       * @return Returns the label or the empty string if the object type is not supported.
77       */
78      public static ColoredString getTextLabel(Object   obj, long flags) {
79          if (obj instanceof IJavaElement) {
80              return getElementLabel((IJavaElement) obj, flags);
81          } else if (obj instanceof IResource) {
82              return new ColoredString(((IResource) obj).getName());
83          } else if (obj instanceof ClassPathContainer) {
84              ClassPathContainer container= (ClassPathContainer) obj;
85              return getContainerEntryLabel(container.getClasspathEntry().getPath(), container.getJavaProject());
86          }
87          return new ColoredString(JavaElementLabels.getTextLabel(obj, flags));
88      }
89                  
90      /**
91       * Returns the label for a Java element with the flags as defined by this class.
92       * @param element The element to render.
93       * @param flags The rendering flags.
94       * @return the label of the Java element
95       */
96      public static ColoredString getElementLabel(IJavaElement element, long flags) {
97          ColoredString result= new ColoredString();
98          getElementLabel(element, flags, result);
99          return result;
100     }
101     
102     /**
103      * Returns the label for a Java element with the flags as defined by this class.
104      * @param element The element to render.
105      * @param flags The rendering flags.
106      * @param result The buffer to append the resulting label to.
107      */
108     public static void getElementLabel(IJavaElement element, long flags, ColoredString result) {
109         int type= element.getElementType();
110         IPackageFragmentRoot root= null;
111         
112         if (type != IJavaElement.JAVA_MODEL && type != IJavaElement.JAVA_PROJECT && type != IJavaElement.PACKAGE_FRAGMENT_ROOT)
113             root= JavaModelUtil.getPackageFragmentRoot(element);
114         if (root != null && getFlag(flags, JavaElementLabels.PREPEND_ROOT_PATH)) {
115             getPackageFragmentRootLabel(root, JavaElementLabels.ROOT_QUALIFIED, result);
116             result.append(JavaElementLabels.CONCAT_STRING);
117         }       
118         
119         switch (type) {
120             case IJavaElement.METHOD:
121                 getMethodLabel((IMethod) element, flags, result);
122                 break;
123             case IJavaElement.FIELD: 
124                 getFieldLabel((IField) element, flags, result);
125                 break;
126             case IJavaElement.LOCAL_VARIABLE: 
127                 getLocalVariableLabel((ILocalVariable) element, flags, result);
128                 break;
129             case IJavaElement.INITIALIZER:
130                 getInitializerLabel((IInitializer) element, flags, result);
131                 break;              
132             case IJavaElement.TYPE: 
133                 getTypeLabel((IType) element, flags, result);
134                 break;
135             case IJavaElement.CLASS_FILE: 
136                 getClassFileLabel((IClassFile) element, flags, result);
137                 break;                  
138             case IJavaElement.COMPILATION_UNIT: 
139                 getCompilationUnitLabel((ICompilationUnit) element, flags, result);
140                 break;  
141             case IJavaElement.PACKAGE_FRAGMENT: 
142                 getPackageFragmentLabel((IPackageFragment) element, flags, result);
143                 break;
144             case IJavaElement.PACKAGE_FRAGMENT_ROOT: 
145                 getPackageFragmentRootLabel((IPackageFragmentRoot) element, flags, result);
146                 break;
147             case IJavaElement.IMPORT_CONTAINER:
148             case IJavaElement.IMPORT_DECLARATION:
149             case IJavaElement.PACKAGE_DECLARATION:
150                 getDeclarationLabel(element, flags, result);
151                 break;
152             case IJavaElement.JAVA_PROJECT:
153             case IJavaElement.JAVA_MODEL:
154                 result.append(element.getElementName());
155                 break;
156             default:
157                 result.append(element.getElementName());
158         }
159         
160         if (root != null && getFlag(flags, JavaElementLabels.APPEND_ROOT_PATH)) {
161             int offset= result.length();
162             result.append(JavaElementLabels.CONCAT_STRING);
163             getPackageFragmentRootLabel(root, JavaElementLabels.ROOT_QUALIFIED, result);
164             
165             if (getFlag(flags, COLORIZE)) {
166                 result.colorize(offset, result.length() - offset, QUALIFIER_STYLE);
167             }
168             
169         }
170     }
171 
172     /**
173      * Appends the label for a method to a {@link ColoredString}. Considers the M_* flags.
174      *  @param method The element to render.
175      * @param flags The rendering flags. Flags with names starting with 'M_' are considered.
176      * @param result The buffer to append the resulting label to.
177      */     
178     public static void getMethodLabel(IMethod method, long flags, ColoredString result) {
179         try {
180             BindingKey resolvedKey= getFlag(flags, JavaElementLabels.USE_RESOLVED) && method.isResolved() ? new BindingKey(method.getKey()) : null;
181             String   resolvedSig= (resolvedKey != null) ? resolvedKey.toSignature() : null;
182             
183             // type parameters
184             if (getFlag(flags, JavaElementLabels.M_PRE_TYPE_PARAMETERS)) {
185                 if (resolvedKey != null) {
186                     if (resolvedKey.isParameterizedMethod()) {
187                         String  [] typeArgRefs= resolvedKey.getTypeArguments();
188                         if (typeArgRefs.length > 0) {
189                             getTypeArgumentSignaturesLabel(typeArgRefs, flags, result);
190                             result.append(' ');
191                         }
192                     } else {
193                         String  [] typeParameterSigs= Signature.getTypeParameters(resolvedSig);
194                         if (typeParameterSigs.length > 0) {
195                             getTypeParameterSignaturesLabel(typeParameterSigs, flags, result);
196                             result.append(' ');
197                         }
198                     }
199                 } else if (method.exists()) {
200                     ITypeParameter[] typeParameters= method.getTypeParameters();
201                     if (typeParameters.length > 0) {
202                         getTypeParametersLabel(typeParameters, flags, result);
203                         result.append(' ');
204                     }
205                 }
206             }
207             
208             // return type
209             if (getFlag(flags, JavaElementLabels.M_PRE_RETURNTYPE) && method.exists() && !method.isConstructor()) {
210                 String   returnTypeSig= resolvedSig != null ? Signature.getReturnType(resolvedSig) : method.getReturnType();
211                 getTypeSignatureLabel(returnTypeSig, flags, result);
212                 result.append(' ');
213             }
214             
215             // qualification
216             if (getFlag(flags, JavaElementLabels.M_FULLY_QUALIFIED)) {
217                 getTypeLabel(method.getDeclaringType(), JavaElementLabels.T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS), result);
218                 result.append('.');
219             }
220                 
221             result.append(method.getElementName());
222             
223             // parameters
224             result.append('(');
225             if (getFlag(flags, JavaElementLabels.M_PARAMETER_TYPES | JavaElementLabels.M_PARAMETER_NAMES)) {
226                 String  [] types= null;
227                 int nParams= 0;
228                 boolean renderVarargs= false;
229                 if (getFlag(flags, JavaElementLabels.M_PARAMETER_TYPES)) {
230                     if (resolvedSig != null) {
231                         types= Signature.getParameterTypes(resolvedSig);
232                     } else {
233                         types= method.getParameterTypes();
234                     }
235                     nParams= types.length;
236                     renderVarargs= method.exists() && Flags.isVarargs(method.getFlags());
237                 }
238                 String  [] names= null;
239                 if (getFlag(flags, JavaElementLabels.M_PARAMETER_NAMES) && method.exists()) {
240                     names= method.getParameterNames();
241                     if (types == null) {
242                         nParams= names.length;
243                     } else { // types != null
244                         if (nParams != names.length) {
245                             if (resolvedSig != null && types.length > names.length) {
246                                 // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=99137
247                                 nParams= names.length;
248                                 String  [] typesWithoutSyntheticParams= new String  [nParams];
249                                 System.arraycopy(types, types.length - nParams, typesWithoutSyntheticParams, 0, nParams);
250                                 types= typesWithoutSyntheticParams;
251                             } else {
252                                 // https://bugs.eclipse.org/bugs/show_bug.cgi?id=101029
253                                 // JavaPlugin.logErrorMessage("JavaElementLabels: Number of param types(" + nParams + ") != number of names(" + names.length + "): " + method.getElementName());   //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
254                                 names= null; // no names rendered
255                             }
256                         }
257                     }
258                 }
259                 
260                 for (int i= 0; i < nParams; i++) {
261                     if (i > 0) {
262                         result.append(JavaElementLabels.COMMA_STRING);
263                     }
264                     if (types != null) {
265                         String   paramSig= types[i];
266                         if (renderVarargs && (i == nParams - 1)) {
267                             int newDim= Signature.getArrayCount(paramSig) - 1;
268                             getTypeSignatureLabel(Signature.getElementType(paramSig), flags, result);
269                             for (int k= 0; k < newDim; k++) {
270                                 result.append('[').append(']');
271                             }
272                             result.append(JavaElementLabels.ELLIPSIS_STRING);
273                         } else {
274                             getTypeSignatureLabel(paramSig, flags, result);
275                         }
276                     }
277                     if (names != null) {
278                         if (types != null) {
279                             result.append(' ');
280                         }
281                         result.append(names[i]);
282                     }
283                 }
284             } else {
285                 if (method.getParameterTypes().length > 0) {
286                     result.append(JavaElementLabels.ELLIPSIS_STRING);
287                 }
288             }
289             result.append(')');
290                     
291             if (getFlag(flags, JavaElementLabels.M_EXCEPTIONS)) {
292                 String  [] types;
293                 if (resolvedKey != null) {
294                     types= resolvedKey.getThrownExceptions();
295                 } else {
296                     types= method.exists() ? method.getExceptionTypes() : new String  [0];
297                 }
298                 if (types.length > 0) {
299                     result.append(" throws "); //$NON-NLS-1$
300                     for (int i= 0; i < types.length; i++) {
301                         if (i > 0) {
302                             result.append(JavaElementLabels.COMMA_STRING);
303                         }
304                         getTypeSignatureLabel(types[i], flags, result);
305                     }
306                 }
307             }
308             
309             if (getFlag(flags, JavaElementLabels.M_APP_TYPE_PARAMETERS)) {
310                 int offset= result.length();
311                 if (resolvedKey != null) {
312                     if (resolvedKey.isParameterizedMethod()) {
313                         String  [] typeArgRefs= resolvedKey.getTypeArguments();
314                         if (typeArgRefs.length > 0) {
315                             result.append(' ');
316                             getTypeArgumentSignaturesLabel(typeArgRefs, flags, result);
317                         }
318                     } else {
319                         String  [] typeParameterSigs= Signature.getTypeParameters(resolvedSig);
320                         if (typeParameterSigs.length > 0) {
321                             result.append(' ');
322                             getTypeParameterSignaturesLabel(typeParameterSigs, flags, result);
323                         }
324                     }
325                 } else if (method.exists()) {
326                     ITypeParameter[] typeParameters= method.getTypeParameters();
327                     if (typeParameters.length > 0) {
328                         result.append(' ');
329                         getTypeParametersLabel(typeParameters, flags, result);
330                     }
331                 }
332                 if (getFlag(flags, COLORIZE)) {
333                     result.colorize(offset, result.length() - offset, APPENDED_TYPE_STYLE);
334                 }
335             }
336             
337             if (getFlag(flags, JavaElementLabels.M_APP_RETURNTYPE) && method.exists() && !method.isConstructor()) {
338                 int offset= result.length();
339                 result.append(JavaElementLabels.DECL_STRING);
340                 String   returnTypeSig= resolvedSig != null ? Signature.getReturnType(resolvedSig) : method.getReturnType();
341                 getTypeSignatureLabel(returnTypeSig, flags, result);
342                 if (getFlag(flags, COLORIZE)) {
343                     result.colorize(offset, result.length() - offset, APPENDED_TYPE_STYLE);
344                 }
345             }           
346 
347             // category
348             if (getFlag(flags, JavaElementLabels.M_CATEGORY) && method.exists()) 
349                 getCategoryLabel(method, result);
350             
351             // post qualification
352             if (getFlag(flags, JavaElementLabels.M_POST_QUALIFIED)) {
353                 int offset= result.length();
354                 result.append(JavaElementLabels.CONCAT_STRING);
355                 getTypeLabel(method.getDeclaringType(), JavaElementLabels.T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS), result);
356                 if (getFlag(flags, COLORIZE)) {
357                     result.colorize(offset, result.length() - offset, QUALIFIER_STYLE);
358                 }
359             }
360             
361         } catch (JavaModelException e) {
362             JavaPlugin.log(e); // NotExistsException will not reach this point
363         }
364     }
365 
366     private static void getCategoryLabel(IMember member, ColoredString result) throws JavaModelException {
367         String  [] categories= member.getCategories();
368         if (categories.length > 0) {
369             ColoredString categoriesBuf= new ColoredString();
370             for (int i= 0; i < categories.length; i++) {
371                 if (i > 0)
372                     categoriesBuf.append(JavaUIMessages.JavaElementLabels_category_separator_string);
373                 categoriesBuf.append(categories[i]);
374             }
375             result.append(JavaElementLabels.CONCAT_STRING);
376             result.append(Messages.format(JavaUIMessages.JavaElementLabels_category , categoriesBuf.toString()));
377         }
378     }
379     
380     private static void getTypeParametersLabel(ITypeParameter[] typeParameters, long flags, ColoredString result) {
381         if (typeParameters.length > 0) {
382             result.append('<');
383             for (int i = 0; i < typeParameters.length; i++) {
384                 if (i > 0) {
385                     result.append(JavaElementLabels.COMMA_STRING);
386                 }
387                 result.append(typeParameters[i].getElementName());
388             }
389             result.append('>');
390         }
391     }
392     
393     /**
394      * Appends the label for a field to a {@link ColoredString}. Considers the F_* flags.
395      *  @param field The element to render.
396      * @param flags The rendering flags. Flags with names starting with 'F_' are considered.
397      * @param result The buffer to append the resulting label to.
398      */ 
399     public static void getFieldLabel(IField field, long flags, ColoredString result) {
400         try {
401             
402             if (getFlag(flags, JavaElementLabels.F_PRE_TYPE_SIGNATURE) && field.exists() && !Flags.isEnum(field.getFlags())) {
403                 if (getFlag(flags, JavaElementLabels.USE_RESOLVED) && field.isResolved()) {
404                     getTypeSignatureLabel(new BindingKey(field.getKey()).toSignature(), flags, result);
405                 } else {
406                     getTypeSignatureLabel(field.getTypeSignature(), flags, result);
407                 }
408                 result.append(' ');
409             }
410             
411             // qualification
412             if (getFlag(flags, JavaElementLabels.F_FULLY_QUALIFIED)) {
413                 getTypeLabel(field.getDeclaringType(), JavaElementLabels.T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS), result);
414                 result.append('.');
415             }
416             result.append(field.getElementName());
417             
418             if (getFlag(flags, JavaElementLabels.F_APP_TYPE_SIGNATURE) && field.exists() && !Flags.isEnum(field.getFlags())) {
419                 int offset= result.length();
420                 result.append(JavaElementLabels.DECL_STRING);
421                 if (getFlag(flags, JavaElementLabels.USE_RESOLVED) && field.isResolved()) {
422                     getTypeSignatureLabel(new BindingKey(field.getKey()).toSignature(), flags, result);
423                 } else {
424                     getTypeSignatureLabel(field.getTypeSignature(), flags, result);
425                 }
426                 if (getFlag(flags, COLORIZE)) {
427                     result.colorize(offset, result.length() - offset, APPENDED_TYPE_STYLE);
428                 }
429             }
430 
431             // category
432             if (getFlag(flags, JavaElementLabels.F_CATEGORY) && field.exists())
433                 getCategoryLabel(field, result);
434 
435             // post qualification
436             if (getFlag(flags, JavaElementLabels.F_POST_QUALIFIED)) {
437                 int offset= result.length();
438                 result.append(JavaElementLabels.CONCAT_STRING);
439                 getTypeLabel(field.getDeclaringType(), JavaElementLabels.T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS), result);
440                 if (getFlag(flags, COLORIZE)) {
441                     result.colorize(offset, result.length() - offset, QUALIFIER_STYLE);
442                 }
443             }
444 
445         } catch (JavaModelException e) {
446             JavaPlugin.log(e); // NotExistsException will not reach this point
447         }           
448     }
449     
450     /**
451      * Appends the label for a local variable to a {@link ColoredString}.
452      *  @param localVariable The element to render.
453      * @param flags The rendering flags. Flags with names starting with 'F_' are considered.
454      * @param result The buffer to append the resulting label to.
455      */ 
456     public static void getLocalVariableLabel(ILocalVariable localVariable, long flags, ColoredString result) {
457         if (getFlag(flags, JavaElementLabels.F_PRE_TYPE_SIGNATURE)) {
458             getTypeSignatureLabel(localVariable.getTypeSignature(), flags, result);
459             result.append(' ');
460         }
461         
462         if (getFlag(flags, JavaElementLabels.F_FULLY_QUALIFIED)) {
463             getElementLabel(localVariable.getParent(), JavaElementLabels.M_PARAMETER_TYPES | JavaElementLabels.M_FULLY_QUALIFIED | JavaElementLabels.T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS), result);
464             result.append('.');
465         }
466         
467         result.append(localVariable.getElementName());
468         
469         if (getFlag(flags, JavaElementLabels.F_APP_TYPE_SIGNATURE)) {
470             int offset= result.length();
471             result.append(JavaElementLabels.DECL_STRING);
472             getTypeSignatureLabel(localVariable.getTypeSignature(), flags, result);
473             if (getFlag(flags, COLORIZE)) {
474                 result.colorize(offset, result.length() - offset, APPENDED_TYPE_STYLE);
475             }
476         }
477         
478         // post qualification
479         if (getFlag(flags, JavaElementLabels.F_POST_QUALIFIED)) {
480             result.append(JavaElementLabels.CONCAT_STRING);
481             getElementLabel(localVariable.getParent(), JavaElementLabels.M_PARAMETER_TYPES | JavaElementLabels.M_FULLY_QUALIFIED | JavaElementLabels.T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS), result);
482         }
483     }
484     
485     /**
486      * Appends the label for a initializer to a {@link ColoredString}. Considers the I_* flags.
487      *  @param initializer The element to render.
488      * @param flags The rendering flags. Flags with names starting with 'I_' are considered.
489      * @param result The buffer to append the resulting label to.
490      */ 
491     public static void getInitializerLabel(IInitializer initializer, long flags, ColoredString result) {
492         // qualification
493         if (getFlag(flags, JavaElementLabels.I_FULLY_QUALIFIED)) {
494             getTypeLabel(initializer.getDeclaringType(), JavaElementLabels.T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS), result);
495             result.append('.');
496         }
497         result.append(JavaUIMessages.JavaElementLabels_initializer); 
498 
499         // post qualification
500         if (getFlag(flags, JavaElementLabels.I_POST_QUALIFIED)) {
501             int offset= result.length();
502             result.append(JavaElementLabels.CONCAT_STRING);
503             getTypeLabel(initializer.getDeclaringType(), JavaElementLabels.T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS), result);
504             if (getFlag(flags, COLORIZE)) {
505                 result.colorize(offset, result.length() - offset, QUALIFIER_STYLE);
506             }
507         }
508     }
509     
510     private static void getTypeSignatureLabel(String   typeSig, long flags, ColoredString result) {
511         int sigKind= Signature.getTypeSignatureKind(typeSig);
512         switch (sigKind) {
513             case Signature.BASE_TYPE_SIGNATURE:
514                 result.append(Signature.toString(typeSig));
515                 break;
516             case Signature.ARRAY_TYPE_SIGNATURE:
517                 getTypeSignatureLabel(Signature.getElementType(typeSig), flags, result);
518                 for (int dim= Signature.getArrayCount(typeSig); dim > 0; dim--) {
519                     result.append('[').append(']');
520                 }
521                 break;
522             case Signature.CLASS_TYPE_SIGNATURE:
523                 String   baseType= Signature.toString(Signature.getTypeErasure(typeSig));
524                 result.append(Signature.getSimpleName(baseType));
525                 
526                 String  [] typeArguments= Signature.getTypeArguments(typeSig);
527                 getTypeArgumentSignaturesLabel(typeArguments, flags, result);
528                 break;
529             case Signature.TYPE_VARIABLE_SIGNATURE:
530                 result.append(Signature.toString(typeSig));
531                 break;
532             case Signature.WILDCARD_TYPE_SIGNATURE:
533                 char ch= typeSig.charAt(0);
534                 if (ch == Signature.C_STAR) { //workaround for bug 85713
535                     result.append('?');
536                 } else {
537                     if (ch == Signature.C_EXTENDS) {
538                         result.append("? extends "); //$NON-NLS-1$
539                         getTypeSignatureLabel(typeSig.substring(1), flags, result);
540                     } else if (ch == Signature.C_SUPER) {
541                         result.append("? super "); //$NON-NLS-1$
542                         getTypeSignatureLabel(typeSig.substring(1), flags, result);
543                     }
544                 }
545                 break;
546             case Signature.CAPTURE_TYPE_SIGNATURE:
547                 getTypeSignatureLabel(typeSig.substring(1), flags, result);
548                 break;
549             default:
550                 // unknown
551         }
552     }
553     
554     private static void getTypeArgumentSignaturesLabel(String  [] typeArgsSig, long flags, ColoredString result) {
555         if (typeArgsSig.length > 0) {
556             result.append('<');
557             for (int i = 0; i < typeArgsSig.length; i++) {
558                 if (i > 0) {
559                     result.append(JavaElementLabels.COMMA_STRING);
560                 }
561                 getTypeSignatureLabel(typeArgsSig[i], flags, result);
562             }
563             result.append('>');
564         }
565     }
566     
567     private static void getTypeParameterSignaturesLabel(String  [] typeParamSigs, long flags, ColoredString result) {
568         if (typeParamSigs.length > 0) {
569             result.append('<');
570             for (int i = 0; i < typeParamSigs.length; i++) {
571                 if (i > 0) {
572                     result.append(JavaElementLabels.COMMA_STRING);
573                 }
574                 result.append(Signature.getTypeVariable(typeParamSigs[i]));
575             }
576             result.append('>');
577         }
578     }
579     
580 
581     /**
582      * Appends the label for a type to a {@link ColoredString}. Considers the T_* flags.
583      *  @param type The element to render.
584      * @param flags The rendering flags. Flags with names starting with 'T_' are considered.
585      * @param result The buffer to append the resulting label to.
586      */     
587     public static void getTypeLabel(IType type, long flags, ColoredString result) {
588         
589         if (getFlag(flags, JavaElementLabels.T_FULLY_QUALIFIED)) {
590             IPackageFragment pack= type.getPackageFragment();
591             if (!pack.isDefaultPackage()) {
592                 getPackageFragmentLabel(pack, (flags & QUALIFIER_FLAGS), result);
593                 result.append('.');
594             }
595         }
596         if (getFlag(flags, JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.T_CONTAINER_QUALIFIED)) {
597             IType declaringType= type.getDeclaringType();
598             if (declaringType != null) {
599                 getTypeLabel(declaringType, JavaElementLabels.T_CONTAINER_QUALIFIED | (flags & QUALIFIER_FLAGS), result);
600                 result.append('.');
601             }
602             int parentType= type.getParent().getElementType();
603             if (parentType == IJavaElement.METHOD || parentType == IJavaElement.FIELD || parentType == IJavaElement.INITIALIZER) { // anonymous or local
604                 getElementLabel(type.getParent(), 0, result);
605                 result.append('.');
606             }
607         }
608         
609         String   typeName= type.getElementName();
610         if (typeName.length() == 0) { // anonymous
611             try {
612                 if (type.getParent() instanceof IField && type.isEnum()) {
613                     typeName= '{' + JavaElementLabels.ELLIPSIS_STRING + '}'; 
614                 } else {
615                     String   supertypeName;
616                     String  [] superInterfaceNames= type.getSuperInterfaceNames();
617                     if (superInterfaceNames.length > 0) {
618                         supertypeName= Signature.getSimpleName(superInterfaceNames[0]);
619                     } else {
620                         supertypeName= Signature.getSimpleName(type.getSuperclassName());
621                     }
622                     typeName= Messages.format(JavaUIMessages.JavaElementLabels_anonym_type , supertypeName); 
623                 }
624             } catch (JavaModelException e) {
625                 //ignore
626                 typeName= JavaUIMessages.JavaElementLabels_anonym; 
627             }
628         }
629         result.append(typeName);
630         if (getFlag(flags, JavaElementLabels.T_TYPE_PARAMETERS)) {
631             if (getFlag(flags, JavaElementLabels.USE_RESOLVED) && type.isResolved()) {
632                 BindingKey key= new BindingKey(type.getKey());
633                 if (key.isParameterizedType()) {
634                     String  [] typeArguments= key.getTypeArguments();
635                     getTypeArgumentSignaturesLabel(typeArguments, flags, result);
636                 } else {
637                     String  [] typeParameters= Signature.getTypeParameters(key.toSignature());
638                     getTypeParameterSignaturesLabel(typeParameters, flags, result);
639                 }
640             } else if (type.exists()) {
641                 try {
642                     getTypeParametersLabel(type.getTypeParameters(), flags, result);
643                 } catch (JavaModelException e) {
644                     // ignore
645                 }
646             }
647         }
648         
649         // category
650         if (getFlag(flags, JavaElementLabels.T_CATEGORY) && type.exists()) {
651             try {
652                 getCategoryLabel(type, result);
653             } catch (JavaModelException e) {
654                 // ignore
655             }
656         }
657 
658         // post qualification
659         if (getFlag(flags, JavaElementLabels.T_POST_QUALIFIED)) {
660             int offset= result.length();
661             result.append(JavaElementLabels.CONCAT_STRING);
662             IType declaringType= type.getDeclaringType();
663             if (declaringType != null) {
664                 getTypeLabel(declaringType, JavaElementLabels.T_FULLY_QUALIFIED | (flags & QUALIFIER_FLAGS), result);
665                 int parentType= type.getParent().getElementType();
666                 if (parentType == IJavaElement.METHOD || parentType == IJavaElement.FIELD || parentType == IJavaElement.INITIALIZER) { // anonymous or local
667                     result.append('.');
668                     getElementLabel(type.getParent(), 0, result);
669                 }
670             } else {
671                 getPackageFragmentLabel(type.getPackageFragment(), flags & QUALIFIER_FLAGS, result);
672             }
673             if (getFlag(flags, COLORIZE)) {
674                 result.colorize(offset, result.length() - offset, QUALIFIER_STYLE);
675             }
676         }
677     }
678 
679     /**
680      * Appends the label for a import container, import or package declaration to a {@link ColoredString}. Considers the D_* flags.
681      *  @param declaration The element to render.
682      * @param flags The rendering flags. Flags with names starting with 'D_' are considered.
683      * @param result The buffer to append the resulting label to.
684      */ 
685     public static void getDeclarationLabel(IJavaElement declaration, long flags, ColoredString result) {
686         if (getFlag(flags, JavaElementLabels.D_QUALIFIED)) {
687             IJavaElement openable= (IJavaElement) declaration.getOpenable();
688             if (openable != null) {
689                 result.append(getElementLabel(openable, JavaElementLabels.CF_QUALIFIED | JavaElementLabels.CU_QUALIFIED | (flags & QUALIFIER_FLAGS)));
690                 result.append('/');
691             }   
692         }
693         if (declaration.getElementType() == IJavaElement.IMPORT_CONTAINER) {
694             result.append(JavaUIMessages.JavaElementLabels_import_container); 
695         } else {
696             result.append(declaration.getElementName());
697         }
698         // post qualification
699         if (getFlag(flags, JavaElementLabels.D_POST_QUALIFIED)) {
700             int offset= result.length();
701             IJavaElement openable= (IJavaElement) declaration.getOpenable();
702             if (openable != null) {
703                 result.append(JavaElementLabels.CONCAT_STRING);
704                 result.append(getElementLabel(openable, JavaElementLabels.CF_QUALIFIED | JavaElementLabels.CU_QUALIFIED | (flags & QUALIFIER_FLAGS)));
705             }
706             if (getFlag(flags, COLORIZE)) {
707                 result.colorize(offset, result.length() - offset, QUALIFIER_STYLE);
708             }
709         }
710     }   
711     
712     /**
713      * Appends the label for a class file to a {@link ColoredString}. Considers the CF_* flags.
714      *  @param classFile The element to render.
715      * @param flags The rendering flags. Flags with names starting with 'CF_' are considered.
716      * @param result The buffer to append the resulting label to.
717      */ 
718     public static void getClassFileLabel(IClassFile classFile, long flags, ColoredString result) {
719         if (getFlag(flags, JavaElementLabels.CF_QUALIFIED)) {
720             IPackageFragment pack= (IPackageFragment) classFile.getParent();
721             if (!pack.isDefaultPackage()) {
722                 getPackageFragmentLabel(pack, (flags & QUALIFIER_FLAGS), result);
723                 result.append('.');
724             }
725         }
726         result.append(classFile.getElementName());
727         
728         if (getFlag(flags, JavaElementLabels.CF_POST_QUALIFIED)) {
729             int offset= result.length();
730             result.append(JavaElementLabels.CONCAT_STRING);
731             getPackageFragmentLabel((IPackageFragment) classFile.getParent(), flags & QUALIFIER_FLAGS, result);
732             if (getFlag(flags, COLORIZE)) {
733                 result.colorize(offset, result.length() - offset, QUALIFIER_STYLE);
734             }
735         }
736     }
737 
738     /**
739      * Appends the label for a compilation unit to a {@link ColoredString}. Considers the CU_* flags.
740      *  @param cu The element to render.
741      * @param flags The rendering flags. Flags with names starting with 'CU_' are considered.
742      * @param result The buffer to append the resulting label to.
743      */
744     public static void getCompilationUnitLabel(ICompilationUnit cu, long flags, ColoredString result) {
745         if (getFlag(flags, JavaElementLabels.CU_QUALIFIED)) {
746             IPackageFragment pack= (IPackageFragment) cu.getParent();
747             if (!pack.isDefaultPackage()) {
748                 getPackageFragmentLabel(pack, (flags & QUALIFIER_FLAGS), result);
749                 result.append('.');
750             }
751         }
752         result.append(cu.getElementName());
753         
754         if (getFlag(flags, JavaElementLabels.CU_POST_QUALIFIED)) {
755             int offset= result.length();
756             result.append(JavaElementLabels.CONCAT_STRING);
757             getPackageFragmentLabel((IPackageFragment) cu.getParent(), flags & QUALIFIER_FLAGS, result);
758             if (getFlag(flags, COLORIZE)) {
759                 result.colorize(offset, result.length() - offset, QUALIFIER_STYLE);
760             }
761         }       
762     }
763 
764     /**
765      * Appends the label for a package fragment to a {@link ColoredString}. Considers the P_* flags.
766      *  @param pack The element to render.
767      * @param flags The rendering flags. Flags with names starting with P_' are considered.
768      * @param result The buffer to append the resulting label to.
769      */ 
770     public static void getPackageFragmentLabel(IPackageFragment pack, long flags, ColoredString result) {
771         if (getFlag(flags, JavaElementLabels.P_QUALIFIED)) {
772             getPackageFragmentRootLabel((IPackageFragmentRoot) pack.getParent(), JavaElementLabels.ROOT_QUALIFIED, result);
773             result.append('/');
774         }
775         if (pack.isDefaultPackage()) {
776             result.append(JavaElementLabels.DEFAULT_PACKAGE);
777         } else if (getFlag(flags, JavaElementLabels.P_COMPRESSED)) {
778             StringBuffer   buf= new StringBuffer  ();
779             JavaElementLabels.getPackageFragmentLabel(pack, JavaElementLabels.P_COMPRESSED, buf);
780             result.append(buf.toString());
781         } else {
782             result.append(pack.getElementName());
783         }
784         if (getFlag(flags, JavaElementLabels.P_POST_QUALIFIED)) {
785             int offset= result.length();
786             result.append(JavaElementLabels.CONCAT_STRING);
787             getPackageFragmentRootLabel((IPackageFragmentRoot) pack.getParent(), JavaElementLabels.ROOT_QUALIFIED, result);
788             if (getFlag(flags, COLORIZE)) {
789                 result.colorize(offset, result.length() - offset, QUALIFIER_STYLE);
790             }
791         }
792     }
793 
794     /**
795      * Appends the label for a package fragment root to a {@link ColoredString}. Considers the ROOT_* flags.
796      *  @param root The element to render.
797      * @param flags The rendering flags. Flags with names starting with ROOT_' are considered.
798      * @param result The buffer to append the resulting label to.
799      */ 
800     public static void getPackageFragmentRootLabel(IPackageFragmentRoot root, long flags, ColoredString result) {
801         if (root.isArchive())
802             getArchiveLabel(root, flags, result);
803         else
804             getFolderLabel(root, flags, result);
805     }
806     
807     private static void getArchiveLabel(IPackageFragmentRoot root, long flags, ColoredString result) {
808         // Handle variables different   
809         if (getFlag(flags, JavaElementLabels.ROOT_VARIABLE) && getVariableLabel(root, flags, result))
810             return;
811         boolean external= root.isExternal();
812         if (external)
813             getExternalArchiveLabel(root, flags, result);
814         else
815             getInternalArchiveLabel(root, flags, result);
816     }
817     
818     private static boolean getVariableLabel(IPackageFragmentRoot root, long flags, ColoredString result) {
819         try {
820             IClasspathEntry rawEntry= root.getRawClasspathEntry();
821             if (rawEntry != null && rawEntry.getEntryKind() == IClasspathEntry.CPE_VARIABLE) {
822                 IPath path= rawEntry.getPath().makeRelative();
823                 int offset= result.length();
824                 if (getFlag(flags, JavaElementLabels.REFERENCED_ROOT_POST_QUALIFIED)) {
825                     int segements= path.segmentCount();
826                     if (segements > 0) {
827                         result.append(path.segment(segements - 1));
828                         if (segements > 1) {
829                             result.append(JavaElementLabels.CONCAT_STRING);
830                             result.append(path.removeLastSegments(1).toOSString());
831                         }
832                     } else {
833                         result.append(path.toString());
834                     }
835                 } else {
836                     result.append(path.toString());
837                 }
838                 result.append(JavaElementLabels.CONCAT_STRING);
839                 if (root.isExternal())
840                     result.append(root.getPath().toOSString());
841                 else
842                     result.append(root.getPath().makeRelative().toString());
843                 
844                 if (getFlag(flags, COLORIZE)) {
845                     result.colorize(offset, result.length() - offset, QUALIFIER_STYLE);
846                 }
847                 return true;
848             }
849         } catch (JavaModelException e) {
850             JavaPlugin.log(e); // problems with class path
851         }
852         return false;
853     }
854 
855     private static void getExternalArchiveLabel(IPackageFragmentRoot root, long flags, ColoredString result) {
856         IPath path= root.getPath();
857         if (getFlag(flags, JavaElementLabels.REFERENCED_ROOT_POST_QUALIFIED)) {
858             int segements= path.segmentCount();
859             if (segements > 0) {
860                 result.append(path.segment(segements - 1));
861                 int offset= result.length();
862                 if (segements > 1 || path.getDevice() != null) {
863                     result.append(JavaElementLabels.CONCAT_STRING);
864                     result.append(path.removeLastSegments(1).toOSString());
865                 }
866                 if (getFlag(flags, COLORIZE)) {
867                     result.colorize(offset, result.length() - offset, QUALIFIER_STYLE);
868                 }
869             } else {
870                 result.append(path.toOSString());
871             }
872         } else {
873             result.append(path.toOSString());
874         }
875     }
876 
877     private static void getInternalArchiveLabel(IPackageFragmentRoot root, long flags, ColoredString result) {
878         IResource resource= root.getResource();
879         boolean rootQualified= getFlag(flags, JavaElementLabels.ROOT_QUALIFIED);
880         boolean referencedQualified= getFlag(flags, JavaElementLabels.REFERENCED_ROOT_POST_QUALIFIED) && isReferenced(root);
881         if (rootQualified) {
882             result.append(root.getPath().makeRelative().toString());
883         } else {
884             result.append(root.getElementName());
885             int offset= result.length();
886             if (referencedQualified) {
887                 result.append(JavaElementLabels.CONCAT_STRING);
888                 result.append(resource.getParent().getFullPath().makeRelative().toString());
889             } else if (getFlag(flags, JavaElementLabels.ROOT_POST_QUALIFIED)) {
890                 result.append(JavaElementLabels.CONCAT_STRING);
891                 result.append(root.getParent().getPath().makeRelative().toString());
892             } else {
893                 return;
894             }
895             if (getFlag(flags, COLORIZE)) {
896                 result.colorize(offset, result.length() - offset, QUALIFIER_STYLE);
897             }
898         }
899     }
900 
901     private static void getFolderLabel(IPackageFragmentRoot root, long flags, ColoredString result) {
902         IResource resource= root.getResource();
903         boolean rootQualified= getFlag(flags, JavaElementLabels.ROOT_QUALIFIED);
904         boolean referencedQualified= getFlag(flags, JavaElementLabels.REFERENCED_ROOT_POST_QUALIFIED) && isReferenced(root);
905         if (rootQualified) {
906             result.append(root.getPath().makeRelative().toString());
907         } else {
908             if (resource != null) {
909                 IPath projectRelativePath= resource.getProjectRelativePath();
910                 if (projectRelativePath.segmentCount() == 0) {
911                     result.append(resource.getName());
912                     referencedQualified= false;
913                 } else {
914                     result.append(projectRelativePath.toString());
915                 }
916             } else
917                 result.append(root.getElementName());
918             int offset= result.length();
919             if (referencedQualified) {
920                 result.append(JavaElementLabels.CONCAT_STRING);
921                 result.append(resource.getProject().getName());
922             } else if (getFlag(flags, JavaElementLabels.ROOT_POST_QUALIFIED)) {
923                 result.append(JavaElementLabels.CONCAT_STRING);
924                 result.append(root.getParent().getElementName());
925             } else {
926                 return;
927             }
928             if (getFlag(flags, COLORIZE)) {
929                 result.colorize(offset, result.length() - offset, QUALIFIER_STYLE);
930             }
931         }
932     }
933     
934     /**
935      * @param root
936      * @return <code>true</code> if the given package fragment root is
937      * referenced. This means it is owned by a different project but is referenced
938      * by the root's parent. Returns <code>false</code> if the given root
939      * doesn't have an underlying resource.
940      */
941     private static boolean isReferenced(IPackageFragmentRoot root) {
942         IResource resource= root.getResource();
943         if (resource != null) {
944             IProject jarProject= resource.getProject();
945             IProject container= root.getJavaProject().getProject();
946             return !container.equals(jarProject);
947         }
948         return false;
949     }
950         
951     /**
952      * Returns the label of a classpath container
953      * @param containerPath The path of the container.
954      * @param project The project the container is resolved in.
955      * @return Returns the label of the classpath container
956      */
957     public static ColoredString getContainerEntryLabel(IPath containerPath, IJavaProject project) {
958         try {
959             IClasspathContainer container= JavaCore.getClasspathContainer(containerPath, project);
960             String   description= null;
961             if (container != null) {
962                 description= container.getDescription();
963             }
964             if (description == null) {
965                 ClasspathContainerInitializer initializer= JavaCore.getClasspathContainerInitializer(containerPath.segment(0));
966                 if (initializer != null) {
967                     description= initializer.getDescription(containerPath, project);
968                 }
969             }
970             if (description != null) {
971                 ColoredString str= new ColoredString(description);
972                 if (containerPath.segmentCount() > 0 && JavaRuntime.JRE_CONTAINER.equals(containerPath.segment(0))) {
973                     int index= description.indexOf('[');
974                     if (index != -1) {
975                         str.colorize(index, description.length() - index, DECORATIONS_STYLE); 
976                     }
977                 }
978                 return str;
979             }
980         } catch (JavaModelException e) {
981             // ignore
982         }
983         return new ColoredString(containerPath.toString());
984     }
985 
986     public static ColoredString decorateColoredString(ColoredString string, String   decorated, Style color) {
987         String   label= string.getString();
988         int originalStart= decorated.indexOf(label);
989         if (originalStart == -1) {
990             return new ColoredString(decorated); // the decorator did something wild
991         }
992         if (originalStart > 0) {
993             ColoredString newString= new ColoredString(decorated.substring(0, originalStart), color);
994             newString.append(string);
995             string= newString;
996         }
997         if (decorated.length() > originalStart + label.length()) { // decorator appended something
998             return string.append(decorated.substring(originalStart + label.length()), color);
999         }
1000        return string; // no change
1001    }
1002    
1003}
1004
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags