001: /*******************************************************************************
002: * Copyright (c) 2000, 2007 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: *******************************************************************************/package org.eclipse.jdt.internal.ui.viewsupport;
011:
012: import org.eclipse.swt.graphics.Image;
013: import org.eclipse.swt.graphics.Point;
014:
015: import org.eclipse.jface.resource.ImageDescriptor;
016: import org.eclipse.jface.viewers.LabelProvider;
017:
018: import org.eclipse.jdt.core.dom.IBinding;
019: import org.eclipse.jdt.core.dom.IMethodBinding;
020: import org.eclipse.jdt.core.dom.IPackageBinding;
021: import org.eclipse.jdt.core.dom.ITypeBinding;
022: import org.eclipse.jdt.core.dom.IVariableBinding;
023: import org.eclipse.jdt.core.dom.Modifier;
024:
025: import org.eclipse.jdt.internal.corext.util.Messages;
026:
027: import org.eclipse.jdt.ui.JavaElementImageDescriptor;
028: import org.eclipse.jdt.ui.JavaElementLabels;
029:
030: import org.eclipse.jdt.internal.ui.JavaPlugin;
031: import org.eclipse.jdt.internal.ui.JavaPluginImages;
032: import org.eclipse.jdt.internal.ui.JavaUIMessages;
033:
034: /**
035: * Label provider to render bindings in viewers.
036: *
037: * @since 3.1
038: */
039: public class BindingLabelProvider extends LabelProvider {
040:
041: private static int getAdornmentFlags(IBinding binding, int flags) {
042: int adornments = 0;
043: if (binding instanceof IMethodBinding
044: && ((IMethodBinding) binding).isConstructor())
045: adornments |= JavaElementImageDescriptor.CONSTRUCTOR;
046: final int modifiers = binding.getModifiers();
047: if (Modifier.isAbstract(modifiers))
048: adornments |= JavaElementImageDescriptor.ABSTRACT;
049: if (Modifier.isFinal(modifiers))
050: adornments |= JavaElementImageDescriptor.FINAL;
051: if (Modifier.isSynchronized(modifiers))
052: adornments |= JavaElementImageDescriptor.SYNCHRONIZED;
053: if (Modifier.isStatic(modifiers))
054: adornments |= JavaElementImageDescriptor.STATIC;
055: if (binding.isDeprecated())
056: adornments |= JavaElementImageDescriptor.DEPRECATED;
057: if (binding instanceof IVariableBinding
058: && ((IVariableBinding) binding).isField()) {
059: if (Modifier.isTransient(modifiers))
060: adornments |= JavaElementImageDescriptor.TRANSIENT;
061: if (Modifier.isVolatile(modifiers))
062: adornments |= JavaElementImageDescriptor.VOLATILE;
063: }
064: return adornments;
065: }
066:
067: private static ImageDescriptor getBaseImageDescriptor(
068: IBinding binding, int flags) {
069: if (binding instanceof ITypeBinding) {
070: ITypeBinding typeBinding = (ITypeBinding) binding;
071: if (typeBinding.isArray()) {
072: typeBinding = typeBinding.getElementType();
073: }
074: if (typeBinding.isCapture()) {
075: typeBinding.getWildcard();
076: }
077: return getTypeImageDescriptor(typeBinding
078: .getDeclaringClass() != null, typeBinding, flags);
079: } else if (binding instanceof IMethodBinding) {
080: ITypeBinding type = ((IMethodBinding) binding)
081: .getDeclaringClass();
082: int modifiers = binding.getModifiers();
083: if (type.isEnum()
084: && (!Modifier.isPublic(modifiers)
085: && !Modifier.isProtected(modifiers) && !Modifier
086: .isPrivate(modifiers))
087: && ((IMethodBinding) binding).isConstructor())
088: return JavaPluginImages.DESC_MISC_PRIVATE;
089: return getMethodImageDescriptor(binding.getModifiers());
090: } else if (binding instanceof IVariableBinding)
091: return getFieldImageDescriptor((IVariableBinding) binding);
092: return JavaPluginImages.DESC_OBJS_UNKNOWN;
093: }
094:
095: private static ImageDescriptor getClassImageDescriptor(int modifiers) {
096: if (Modifier.isPublic(modifiers)
097: || Modifier.isProtected(modifiers)
098: || Modifier.isPrivate(modifiers))
099: return JavaPluginImages.DESC_OBJS_CLASS;
100: else
101: return JavaPluginImages.DESC_OBJS_CLASS_DEFAULT;
102: }
103:
104: private static ImageDescriptor getFieldImageDescriptor(
105: IVariableBinding binding) {
106: final int modifiers = binding.getModifiers();
107: if (Modifier.isPublic(modifiers) || binding.isEnumConstant())
108: return JavaPluginImages.DESC_FIELD_PUBLIC;
109: if (Modifier.isProtected(modifiers))
110: return JavaPluginImages.DESC_FIELD_PROTECTED;
111: if (Modifier.isPrivate(modifiers))
112: return JavaPluginImages.DESC_FIELD_PRIVATE;
113:
114: return JavaPluginImages.DESC_FIELD_DEFAULT;
115: }
116:
117: private static void getFieldLabel(IVariableBinding binding,
118: long flags, StringBuffer buffer) {
119: if (((flags & JavaElementLabels.F_PRE_TYPE_SIGNATURE) != 0)
120: && !binding.isEnumConstant()) {
121: getTypeLabel(binding.getType(),
122: (flags & JavaElementLabels.T_TYPE_PARAMETERS),
123: buffer);
124: buffer.append(' ');
125: }
126: // qualification
127:
128: if ((flags & JavaElementLabels.F_FULLY_QUALIFIED) != 0) {
129: ITypeBinding declaringClass = binding.getDeclaringClass();
130: if (declaringClass != null) { // test for array.length
131: getTypeLabel(
132: declaringClass,
133: JavaElementLabels.T_FULLY_QUALIFIED
134: | (flags & JavaElementLabels.P_COMPRESSED),
135: buffer);
136: buffer.append('.');
137: }
138: }
139: buffer.append(binding.getName());
140: if (((flags & JavaElementLabels.F_APP_TYPE_SIGNATURE) != 0)
141: && !binding.isEnumConstant()) {
142: buffer.append(JavaElementLabels.DECL_STRING);
143: getTypeLabel(binding.getType(),
144: (flags & JavaElementLabels.T_TYPE_PARAMETERS),
145: buffer);
146: }
147: // post qualification
148: if ((flags & JavaElementLabels.F_POST_QUALIFIED) != 0) {
149: ITypeBinding declaringClass = binding.getDeclaringClass();
150: if (declaringClass != null) { // test for array.length
151: buffer.append(JavaElementLabels.CONCAT_STRING);
152: getTypeLabel(
153: declaringClass,
154: JavaElementLabels.T_FULLY_QUALIFIED
155: | (flags & JavaElementLabels.P_COMPRESSED),
156: buffer);
157: }
158: }
159: }
160:
161: private static void getLocalVariableLabel(IVariableBinding binding,
162: long flags, StringBuffer buffer) {
163: if (((flags & JavaElementLabels.F_PRE_TYPE_SIGNATURE) != 0)) {
164: getTypeLabel(binding.getType(),
165: (flags & JavaElementLabels.T_TYPE_PARAMETERS),
166: buffer);
167: buffer.append(' ');
168: }
169: if (((flags & JavaElementLabels.F_FULLY_QUALIFIED) != 0)) {
170: IMethodBinding declaringMethod = binding
171: .getDeclaringMethod();
172: if (declaringMethod != null) {
173: getMethodLabel(declaringMethod, flags, buffer);
174: buffer.append('.');
175: }
176: }
177: buffer.append(binding.getName());
178: if (((flags & JavaElementLabels.F_APP_TYPE_SIGNATURE) != 0)) {
179: buffer.append(JavaElementLabels.DECL_STRING);
180: getTypeLabel(binding.getType(),
181: (flags & JavaElementLabels.T_TYPE_PARAMETERS),
182: buffer);
183: }
184: }
185:
186: private static ImageDescriptor getInnerClassImageDescriptor(
187: int modifiers) {
188: if (Modifier.isPublic(modifiers))
189: return JavaPluginImages.DESC_OBJS_INNER_CLASS_PUBLIC;
190: else if (Modifier.isPrivate(modifiers))
191: return JavaPluginImages.DESC_OBJS_INNER_CLASS_PRIVATE;
192: else if (Modifier.isProtected(modifiers))
193: return JavaPluginImages.DESC_OBJS_INNER_CLASS_PROTECTED;
194: else
195: return JavaPluginImages.DESC_OBJS_INNER_CLASS_DEFAULT;
196: }
197:
198: private static ImageDescriptor getInnerInterfaceImageDescriptor(
199: int modifiers) {
200: if (Modifier.isPublic(modifiers))
201: return JavaPluginImages.DESC_OBJS_INNER_INTERFACE_PUBLIC;
202: else if (Modifier.isPrivate(modifiers))
203: return JavaPluginImages.DESC_OBJS_INNER_INTERFACE_PRIVATE;
204: else if (Modifier.isProtected(modifiers))
205: return JavaPluginImages.DESC_OBJS_INNER_INTERFACE_PROTECTED;
206: else
207: return JavaPluginImages.DESC_OBJS_INTERFACE_DEFAULT;
208: }
209:
210: private static ImageDescriptor getInterfaceImageDescriptor(
211: int modifiers) {
212: if (Modifier.isPublic(modifiers)
213: || Modifier.isProtected(modifiers)
214: || Modifier.isPrivate(modifiers))
215: return JavaPluginImages.DESC_OBJS_INTERFACE;
216: else
217: return JavaPluginImages.DESC_OBJS_INTERFACE_DEFAULT;
218: }
219:
220: private static ImageDescriptor getMethodImageDescriptor(
221: int modifiers) {
222: if (Modifier.isPublic(modifiers))
223: return JavaPluginImages.DESC_MISC_PUBLIC;
224: if (Modifier.isProtected(modifiers))
225: return JavaPluginImages.DESC_MISC_PROTECTED;
226: if (Modifier.isPrivate(modifiers))
227: return JavaPluginImages.DESC_MISC_PRIVATE;
228:
229: return JavaPluginImages.DESC_MISC_DEFAULT;
230: }
231:
232: private static void appendDimensions(int dim, StringBuffer buffer) {
233: for (int i = 0; i < dim; i++) {
234: buffer.append('[').append(']');
235: }
236: }
237:
238: private static void getMethodLabel(IMethodBinding binding,
239: long flags, StringBuffer buffer) {
240: // return type
241: if ((flags & JavaElementLabels.M_PRE_TYPE_PARAMETERS) != 0) {
242: if (binding.isGenericMethod()) {
243: ITypeBinding[] typeParameters = binding
244: .getTypeParameters();
245: if (typeParameters.length > 0) {
246: getTypeParametersLabel(
247: typeParameters,
248: (flags & JavaElementLabels.T_TYPE_PARAMETERS),
249: buffer);
250: buffer.append(' ');
251: }
252: }
253: }
254: // return type
255: if (((flags & JavaElementLabels.M_PRE_RETURNTYPE) != 0)
256: && !binding.isConstructor()) {
257: getTypeLabel(binding.getReturnType(),
258: (flags & JavaElementLabels.T_TYPE_PARAMETERS),
259: buffer);
260: buffer.append(' ');
261: }
262: // qualification
263: if ((flags & JavaElementLabels.M_FULLY_QUALIFIED) != 0) {
264: getTypeLabel(binding.getDeclaringClass(),
265: JavaElementLabels.T_FULLY_QUALIFIED
266: | (flags & JavaElementLabels.P_COMPRESSED),
267: buffer);
268: buffer.append('.');
269: }
270: buffer.append(binding.getName());
271: if ((flags & JavaElementLabels.M_APP_TYPE_PARAMETERS) != 0) {
272: if (binding.isParameterizedMethod()) {
273: ITypeBinding[] typeArguments = binding
274: .getTypeArguments();
275: if (typeArguments.length > 0) {
276: buffer.append(' ');
277: getTypeArgumentsLabel(
278: typeArguments,
279: (flags & JavaElementLabels.T_TYPE_PARAMETERS),
280: buffer);
281: }
282: }
283: }
284:
285: // parameters
286: buffer.append('(');
287: if ((flags & JavaElementLabels.M_PARAMETER_TYPES | JavaElementLabels.M_PARAMETER_NAMES) != 0) {
288: ITypeBinding[] parameters = ((flags & JavaElementLabels.M_PARAMETER_TYPES) != 0) ? binding
289: .getParameterTypes()
290: : null;
291: if (parameters != null) {
292: for (int index = 0; index < parameters.length; index++) {
293: if (index > 0) {
294: buffer.append(JavaElementLabels.COMMA_STRING);
295: }
296: ITypeBinding paramType = parameters[index];
297: if (binding.isVarargs()
298: && (index == parameters.length - 1)) {
299: getTypeLabel(
300: paramType.getElementType(),
301: (flags & JavaElementLabels.T_TYPE_PARAMETERS),
302: buffer);
303: appendDimensions(paramType.getDimensions() - 1,
304: buffer);
305: buffer
306: .append(JavaElementLabels.ELLIPSIS_STRING);
307: } else {
308: getTypeLabel(
309: paramType,
310: (flags & JavaElementLabels.T_TYPE_PARAMETERS),
311: buffer);
312: }
313: }
314: }
315: } else {
316: if (binding.getParameterTypes().length > 0) {
317: buffer.append(JavaElementLabels.ELLIPSIS_STRING);
318: }
319: }
320: buffer.append(')');
321:
322: if ((flags & JavaElementLabels.M_EXCEPTIONS) != 0) {
323: ITypeBinding[] exceptions = binding.getExceptionTypes();
324: if (exceptions.length > 0) {
325: buffer.append(" throws "); //$NON-NLS-1$
326: for (int index = 0; index < exceptions.length; index++) {
327: if (index > 0) {
328: buffer.append(JavaElementLabels.COMMA_STRING);
329: }
330: getTypeLabel(
331: exceptions[index],
332: (flags & JavaElementLabels.T_TYPE_PARAMETERS),
333: buffer);
334: }
335: }
336: }
337: if ((flags & JavaElementLabels.M_APP_TYPE_PARAMETERS) != 0) {
338: if (binding.isGenericMethod()) {
339: ITypeBinding[] typeParameters = binding
340: .getTypeParameters();
341: if (typeParameters.length > 0) {
342: buffer.append(' ');
343: getTypeParametersLabel(
344: typeParameters,
345: (flags & JavaElementLabels.T_TYPE_PARAMETERS),
346: buffer);
347: }
348: }
349: }
350: if (((flags & JavaElementLabels.M_APP_RETURNTYPE) != 0)
351: && !binding.isConstructor()) {
352: buffer.append(JavaElementLabels.DECL_STRING);
353: getTypeLabel(binding.getReturnType(),
354: (flags & JavaElementLabels.T_TYPE_PARAMETERS),
355: buffer);
356: }
357: // post qualification
358: if ((flags & JavaElementLabels.M_POST_QUALIFIED) != 0) {
359: buffer.append(JavaElementLabels.CONCAT_STRING);
360: getTypeLabel(binding.getDeclaringClass(),
361: JavaElementLabels.T_FULLY_QUALIFIED
362: | (flags & JavaElementLabels.P_COMPRESSED),
363: buffer);
364: }
365: }
366:
367: private static ImageDescriptor getTypeImageDescriptor(
368: boolean inner, ITypeBinding binding, int flags) {
369: if (binding.isEnum())
370: return JavaPluginImages.DESC_OBJS_ENUM;
371: else if (binding.isAnnotation())
372: return JavaPluginImages.DESC_OBJS_ANNOTATION;
373: else if (binding.isInterface()) {
374: if ((flags & JavaElementImageProvider.LIGHT_TYPE_ICONS) != 0)
375: return JavaPluginImages.DESC_OBJS_INTERFACEALT;
376: if (inner)
377: return getInnerInterfaceImageDescriptor(binding
378: .getModifiers());
379: return getInterfaceImageDescriptor(binding.getModifiers());
380: } else if (binding.isClass()) {
381: if ((flags & JavaElementImageProvider.LIGHT_TYPE_ICONS) != 0)
382: return JavaPluginImages.DESC_OBJS_CLASSALT;
383: if (inner)
384: return getInnerClassImageDescriptor(binding
385: .getModifiers());
386: return getClassImageDescriptor(binding.getModifiers());
387: } else if (binding.isTypeVariable()) {
388: return JavaPluginImages.DESC_OBJS_TYPEVARIABLE;
389: }
390: // primitive type, wildcard
391: return null;
392: }
393:
394: private static void getTypeLabel(ITypeBinding binding, long flags,
395: StringBuffer buffer) {
396: if ((flags & JavaElementLabels.T_FULLY_QUALIFIED) != 0) {
397: final IPackageBinding pack = binding.getPackage();
398: if (pack != null && !pack.isUnnamed()) {
399: buffer.append(pack.getName());
400: buffer.append('.');
401: }
402: }
403: if ((flags & (JavaElementLabels.T_FULLY_QUALIFIED | JavaElementLabels.T_CONTAINER_QUALIFIED)) != 0) {
404: final ITypeBinding declaring = binding.getDeclaringClass();
405: if (declaring != null) {
406: getTypeLabel(
407: declaring,
408: JavaElementLabels.T_CONTAINER_QUALIFIED
409: | (flags & JavaElementLabels.P_COMPRESSED),
410: buffer);
411: buffer.append('.');
412: }
413: final IMethodBinding declaringMethod = binding
414: .getDeclaringMethod();
415: if (declaringMethod != null) {
416: getMethodLabel(declaringMethod, 0, buffer);
417: buffer.append('.');
418: }
419: }
420:
421: if (binding.isCapture()) {
422: getTypeLabel(binding.getWildcard(), flags
423: & JavaElementLabels.T_TYPE_PARAMETERS, buffer);
424: } else if (binding.isWildcardType()) {
425: buffer.append('?');
426: ITypeBinding bound = binding.getBound();
427: if (bound != null) {
428: if (binding.isUpperbound()) {
429: buffer.append(" extends "); //$NON-NLS-1$
430: } else {
431: buffer.append(" super "); //$NON-NLS-1$
432: }
433: getTypeLabel(bound, flags
434: & JavaElementLabels.T_TYPE_PARAMETERS, buffer);
435: }
436: } else if (binding.isArray()) {
437: getTypeLabel(binding.getElementType(), flags
438: & JavaElementLabels.T_TYPE_PARAMETERS, buffer);
439: appendDimensions(binding.getDimensions(), buffer);
440: } else { // type variables, primitive, reftype
441: String name = binding.getTypeDeclaration().getName();
442: if (name.length() == 0) {
443: if (binding.isEnum()) {
444: buffer
445: .append('{' + JavaElementLabels.ELLIPSIS_STRING + '}');
446: } else if (binding.isAnonymous()) {
447: ITypeBinding[] super Interfaces = binding
448: .getInterfaces();
449: ITypeBinding baseType;
450: if (super Interfaces.length > 0) {
451: baseType = super Interfaces[0];
452: } else {
453: baseType = binding.getSuperclass();
454: }
455: if (baseType != null) {
456: StringBuffer anonymBaseType = new StringBuffer();
457: getTypeLabel(baseType, flags
458: & JavaElementLabels.T_TYPE_PARAMETERS,
459: anonymBaseType);
460: buffer
461: .append(Messages
462: .format(
463: JavaUIMessages.JavaElementLabels_anonym_type,
464: anonymBaseType
465: .toString()));
466: } else {
467: buffer
468: .append(JavaUIMessages.JavaElementLabels_anonym);
469: }
470: } else {
471: buffer.append("UNKNOWN"); //$NON-NLS-1$
472: }
473: } else {
474: buffer.append(name);
475: }
476:
477: if ((flags & JavaElementLabels.T_TYPE_PARAMETERS) != 0) {
478: if (binding.isGenericType()) {
479: getTypeParametersLabel(binding.getTypeParameters(),
480: flags, buffer);
481: } else if (binding.isParameterizedType()) {
482: getTypeArgumentsLabel(binding.getTypeArguments(),
483: flags, buffer);
484: }
485: }
486: }
487:
488: if ((flags & JavaElementLabels.T_POST_QUALIFIED) != 0) {
489: final IMethodBinding declaringMethod = binding
490: .getDeclaringMethod();
491: final ITypeBinding declaringType = binding
492: .getDeclaringClass();
493: if (declaringMethod != null) {
494: buffer.append(JavaElementLabels.CONCAT_STRING);
495: getMethodLabel(
496: declaringMethod,
497: JavaElementLabels.T_FULLY_QUALIFIED
498: | (flags & JavaElementLabels.P_COMPRESSED),
499: buffer);
500: } else if (declaringType != null) {
501: buffer.append(JavaElementLabels.CONCAT_STRING);
502: getTypeLabel(
503: declaringType,
504: JavaElementLabels.T_FULLY_QUALIFIED
505: | (flags & JavaElementLabels.P_COMPRESSED),
506: buffer);
507: } else {
508: final IPackageBinding pack = binding.getPackage();
509: if (pack != null && !pack.isUnnamed()) {
510: buffer.append(JavaElementLabels.CONCAT_STRING);
511: buffer.append(pack.getName());
512: }
513: }
514: }
515: }
516:
517: private static void getTypeArgumentsLabel(ITypeBinding[] typeArgs,
518: long flags, StringBuffer buf) {
519: if (typeArgs.length > 0) {
520: buf.append('<');
521: for (int i = 0; i < typeArgs.length; i++) {
522: if (i > 0) {
523: buf.append(JavaElementLabels.COMMA_STRING);
524: }
525: getTypeLabel(typeArgs[i], flags
526: & JavaElementLabels.T_TYPE_PARAMETERS, buf);
527: }
528: buf.append('>');
529: }
530: }
531:
532: private static void getTypeParametersLabel(
533: ITypeBinding[] typeParameters, long flags,
534: StringBuffer buffer) {
535: if (typeParameters.length > 0) {
536: buffer.append('<');
537: for (int index = 0; index < typeParameters.length; index++) {
538: if (index > 0) {
539: buffer.append(JavaElementLabels.COMMA_STRING);
540: }
541: buffer.append(typeParameters[index].getName());
542: }
543: buffer.append('>');
544: }
545: }
546:
547: /**
548: * Returns the label for a Java element with the flags as defined by {@link JavaElementLabels}.
549: * @param binding The binding to render.
550: * @param flags The text flags as defined in {@link JavaElementLabels}
551: * @return the label of the binding
552: */
553: public static String getBindingLabel(IBinding binding, long flags) {
554: StringBuffer buffer = new StringBuffer(60);
555: if (binding instanceof ITypeBinding) {
556: getTypeLabel(((ITypeBinding) binding), flags, buffer);
557: } else if (binding instanceof IMethodBinding) {
558: getMethodLabel(((IMethodBinding) binding), flags, buffer);
559: } else if (binding instanceof IVariableBinding) {
560: final IVariableBinding variable = (IVariableBinding) binding;
561: if (variable.isField())
562: getFieldLabel(variable, flags, buffer);
563: else
564: getLocalVariableLabel(variable, flags, buffer);
565: }
566: return buffer.toString();
567: }
568:
569: /**
570: * Returns the image descriptor for a binding with the flags as defined by {@link JavaElementImageProvider}.
571: * @param binding The binding to get the image for.
572: * @param imageFlags The image flags as defined in {@link JavaElementImageProvider}.
573: * @return the image of the binding or null if there is no image
574: */
575: public static ImageDescriptor getBindingImageDescriptor(
576: IBinding binding, int imageFlags) {
577: ImageDescriptor baseImage = getBaseImageDescriptor(binding,
578: imageFlags);
579: if (baseImage != null) {
580: int adornmentFlags = getAdornmentFlags(binding, imageFlags);
581: Point size = ((imageFlags & JavaElementImageProvider.SMALL_ICONS) != 0) ? JavaElementImageProvider.SMALL_SIZE
582: : JavaElementImageProvider.BIG_SIZE;
583: return new JavaElementImageDescriptor(baseImage,
584: adornmentFlags, size);
585: }
586: return null;
587: }
588:
589: public static final long DEFAULT_TEXTFLAGS = JavaElementLabels.ALL_DEFAULT;
590: public static final int DEFAULT_IMAGEFLAGS = JavaElementImageProvider.OVERLAY_ICONS;
591:
592: final private long fTextFlags;
593: final private int fImageFlags;
594:
595: private ImageDescriptorRegistry fRegistry;
596:
597: /**
598: * Creates a new binding label provider with default text and image flags
599: */
600: public BindingLabelProvider() {
601: this (DEFAULT_TEXTFLAGS, DEFAULT_IMAGEFLAGS);
602: }
603:
604: /**
605: * @param textFlags Flags defined in {@link JavaElementLabels}.
606: * @param imageFlags Flags defined in {@link JavaElementImageProvider}.
607: */
608: public BindingLabelProvider(final long textFlags,
609: final int imageFlags) {
610: fImageFlags = imageFlags;
611: fTextFlags = textFlags;
612: fRegistry = null;
613: }
614:
615: /*
616: * @see org.eclipse.jface.viewers.ILabelProvider#getImage(java.lang.Object)
617: */
618: public Image getImage(Object element) {
619: if (element instanceof IBinding) {
620: ImageDescriptor baseImage = getBindingImageDescriptor(
621: (IBinding) element, fImageFlags);
622: if (baseImage != null) {
623: return getRegistry().get(baseImage);
624: }
625: }
626: return super .getImage(element);
627: }
628:
629: private ImageDescriptorRegistry getRegistry() {
630: if (fRegistry == null)
631: fRegistry = JavaPlugin.getImageDescriptorRegistry();
632: return fRegistry;
633: }
634:
635: /*
636: * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object)
637: */
638: public String getText(Object element) {
639: if (element instanceof IBinding) {
640: return getBindingLabel((IBinding) element, fTextFlags);
641: }
642: return super.getText(element);
643: }
644: }
|