net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/ui/viewsupport/JavaElementImageProvider.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2003 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpdt.internal.ui.viewsupport;
  12
  13 import net.sourceforge.phpdt.core.Flags;
  14 import net.sourceforge.phpdt.core.IField;
  15 import net.sourceforge.phpdt.core.IJavaElement;
  16 import net.sourceforge.phpdt.core.IJavaProject;
  17 import net.sourceforge.phpdt.core.IMember;
  18 import net.sourceforge.phpdt.core.IMethod;
  19 //import net.sourceforge.phpdt.core.IPackageFragmentRoot;
  20 import net.sourceforge.phpdt.core.IType;
  21 import net.sourceforge.phpdt.core.JavaModelException;
  22 import net.sourceforge.phpdt.internal.ui.PHPUIMessages;
  23 import net.sourceforge.phpdt.internal.ui.PHPUiImages;
  24 import net.sourceforge.phpdt.ui.JavaElementImageDescriptor;
  25 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  26
  27 import org.eclipse.core.resources.IFile;
  28 import org.eclipse.core.resources.IProject;
  29 import org.eclipse.core.runtime.IAdaptable;
  30 import org.eclipse.jface.resource.ImageDescriptor;
  31 //incastrix
  32 //import org.eclipse.jface.text.Assert;
  33 import org.eclipse.core.runtime.Assert;
  34 import org.eclipse.swt.graphics.Image;
  35 import org.eclipse.swt.graphics.Point;
  36 //import org.eclipse.ui.ISharedImages;
  37 //import org.eclipse.ui.ide.IDE.SharedImages;
  38 import org.eclipse.ui.model.IWorkbenchAdapter;
  39
  40 /**
  41  * Default strategy of the Java plugin for the construction of Java element
  42  * icons.
  43  */
  44 public class JavaElementImageProvider {
  45
  46         /**
  47          * Flags for the JavaImageLabelProvider: Generate images with overlays.
  48          */
  49         public final static int OVERLAY_ICONS = 0x1;
  50
  51         /**
  52          * Generate small sized images.
  53          */
  54         public final static int SMALL_ICONS = 0x2;
  55
  56         /**
  57          * Use the 'light' style for rendering types.
  58          */
  59         public final static int LIGHT_TYPE_ICONS = 0x4;
  60
  61         public static final Point SMALL_SIZE = new Point(16, 16);
  62
  63         public static final Point BIG_SIZE = new Point(22, 16);
  64
  65         private static ImageDescriptor DESC_OBJ_PROJECT_CLOSED;
  66
  67         private static ImageDescriptor DESC_OBJ_PROJECT;
  68
  69 //      private static ImageDescriptor DESC_OBJ_FOLDER;
  70 //      {
  71 //              ISharedImages images = PHPeclipsePlugin.getDefault().getWorkbench()
  72 //                              .getSharedImages();
  73 //              DESC_OBJ_PROJECT_CLOSED = images
  74 //                              .getImageDescriptor(SharedImages.IMG_OBJ_PROJECT_CLOSED);
  75 //              DESC_OBJ_PROJECT = images
  76 //                              .getImageDescriptor(SharedImages.IMG_OBJ_PROJECT);
  77 //              DESC_OBJ_FOLDER = images
  78 //                              .getImageDescriptor(ISharedImages.IMG_OBJ_FOLDER);
  79 //      }
  80
  81         private ImageDescriptorRegistry fRegistry;
  82
  83         public JavaElementImageProvider() {
  84                 fRegistry = null; // lazy initialization
  85         }
  86
  87         /**
  88          * Returns the icon for a given element. The icon depends on the element
  89          * type and element properties. If configured, overlay icons are constructed
  90          * for <code>ISourceReference</code>s.
  91          *
  92          * @param flags
  93          *            Flags as defined by the JavaImageLabelProvider
  94          */
  95         public Image getImageLabel(Object element, int flags) {
  96                 return getImageLabel(computeDescriptor(element, flags));
  97         }
  98
  99         private Image getImageLabel(ImageDescriptor descriptor) {
 100                 if (descriptor == null)
 101                         return null;
 102                 return getRegistry().get(descriptor);
 103         }
 104
 105         private ImageDescriptorRegistry getRegistry() {
 106                 if (fRegistry == null) {
 107                         fRegistry = PHPeclipsePlugin.getImageDescriptorRegistry();
 108                 }
 109                 return fRegistry;
 110         }
 111
 112         private ImageDescriptor computeDescriptor(Object element, int flags) {
 113                 if (element instanceof IJavaElement) {
 114                         return getJavaImageDescriptor((IJavaElement) element, flags);
 115                 } else if (element instanceof IFile) {
 116                         IFile file = (IFile) element;
 117                         if ("java".equals(file.getFileExtension())) { //$NON-NLS-1$
 118                                 return getCUResourceImageDescriptor(file, flags); // image for
 119                                                                                                                                         // a CU not
 120                                                                                                                                         // on the
 121                                                                                                                                         // build
 122                                                                                                                                         // path
 123                         }
 124                         return getWorkbenchImageDescriptor(file, flags);
 125                 } else if (element instanceof IAdaptable) {
 126                         return getWorkbenchImageDescriptor((IAdaptable) element, flags);
 127                 }
 128                 return null;
 129         }
 130
 131         private static boolean showOverlayIcons(int flags) {
 132                 return (flags & OVERLAY_ICONS) != 0;
 133         }
 134
 135         private static boolean useSmallSize(int flags) {
 136                 return (flags & SMALL_ICONS) != 0;
 137         }
 138
 139         private static boolean useLightIcons(int flags) {
 140                 return (flags & LIGHT_TYPE_ICONS) != 0;
 141         }
 142
 143         /**
 144          * Returns an image descriptor for a compilatio unit not on the class path.
 145          * The descriptor includes overlays, if specified.
 146          */
 147         public ImageDescriptor getCUResourceImageDescriptor(IFile file, int flags) {
 148                 Point size = useSmallSize(flags) ? SMALL_SIZE : BIG_SIZE;
 149                 return new JavaElementImageDescriptor(
 150                                 PHPUiImages.DESC_OBJS_CUNIT_RESOURCE, 0, size);
 151         }
 152
 153         /**
 154          * Returns an image descriptor for a java element. The descriptor includes
 155          * overlays, if specified.
 156          */
 157         public ImageDescriptor getJavaImageDescriptor(IJavaElement element,
 158                         int flags) {
 159                 int adornmentFlags = computeJavaAdornmentFlags(element, flags);
 160                 Point size = useSmallSize(flags) ? SMALL_SIZE : BIG_SIZE;
 161                 return new JavaElementImageDescriptor(getBaseImageDescriptor(element,
 162                                 flags), adornmentFlags, size);
 163         }
 164
 165         /**
 166          * Returns an image descriptor for a IAdaptable. The descriptor includes
 167          * overlays, if specified (only error ticks apply). Returns
 168          * <code>null</code> if no image could be found.
 169          */
 170         public ImageDescriptor getWorkbenchImageDescriptor(IAdaptable adaptable,
 171                         int flags) {
 172                 IWorkbenchAdapter wbAdapter = (IWorkbenchAdapter) adaptable
 173                                 .getAdapter(IWorkbenchAdapter.class);
 174                 if (wbAdapter == null) {
 175                         return null;
 176                 }
 177                 ImageDescriptor descriptor = wbAdapter.getImageDescriptor(adaptable);
 178                 if (descriptor == null) {
 179                         return null;
 180                 }
 181
 182                 Point size = useSmallSize(flags) ? SMALL_SIZE : BIG_SIZE;
 183                 return new JavaElementImageDescriptor(descriptor, 0, size);
 184         }
 185
 186         // ---- Computation of base image key
 187         // -------------------------------------------------
 188
 189         /**
 190          * Returns an image descriptor for a java element. This is the base image,
 191          * no overlays.
 192          */
 193         public ImageDescriptor getBaseImageDescriptor(IJavaElement element,
 194                         int renderFlags) {
 195                 IType type = null;
 196                 boolean isInterface = false;
 197                 try {
 198                         switch (element.getElementType()) {
 199                         case IJavaElement.INITIALIZER:
 200                                 return PHPUiImages.DESC_MISC_PRIVATE; // 23479
 201                         case IJavaElement.METHOD:
 202                                 IMember member = (IMember) element;
 203                                 type = member.getDeclaringType();
 204                                 isInterface = (type != null)
 205                                                 && member.getDeclaringType().isInterface();
 206                                 return getMethodImageDescriptor(isInterface, member.getFlags());
 207                         case IJavaElement.FIELD:
 208                                 IField field = (IField) element;
 209                                 return getFieldImageDescriptor(field.getDeclaringType()
 210                                                 .isInterface(), field.getFlags());
 211
 212                         case IJavaElement.PACKAGE_DECLARATION:
 213                                 return PHPUiImages.DESC_OBJS_PACKDECL;
 214
 215                         case IJavaElement.IMPORT_DECLARATION:
 216                                 return PHPUiImages.DESC_OBJS_IMPDECL;
 217
 218                         case IJavaElement.IMPORT_CONTAINER:
 219                                 return PHPUiImages.DESC_OBJS_IMPCONT;
 220
 221                         case IJavaElement.TYPE: {
 222                                 type = (IType) element;
 223                                 isInterface = type.isInterface();
 224
 225                                 if (useLightIcons(renderFlags)) {
 226                                         return isInterface ? PHPUiImages.DESC_OBJS_INTERFACEALT
 227                                                         : PHPUiImages.DESC_OBJS_CLASSALT;
 228                                 }
 229                                 boolean isInner = type.getDeclaringType() != null;
 230                                 return getTypeImageDescriptor(isInterface, isInner, type
 231                                                 .getFlags());
 232                         }
 233
 234                         case IJavaElement.PACKAGE_FRAGMENT_ROOT: {
 235                                 //IPackageFragmentRoot root = (IPackageFragmentRoot) element;
 236                                 // if (root.isArchive()) {
 237                                 // IPath attach= root.getSourceAttachmentPath();
 238                                 // if (root.isExternal()) {
 239                                 // if (attach == null) {
 240                                 // return PHPUiImages.DESC_OBJS_EXTJAR;
 241                                 // } else {
 242                                 // return PHPUiImages.DESC_OBJS_EXTJAR_WSRC;
 243                                 // }
 244                                 // } else {
 245                                 // if (attach == null) {
 246                                 // return PHPUiImages.DESC_OBJS_JAR;
 247                                 // } else {
 248                                 // return PHPUiImages.DESC_OBJS_JAR_WSRC;
 249                                 // }
 250                                 // }
 251                                 // } else {
 252                                 return PHPUiImages.DESC_OBJS_PACKFRAG_ROOT;
 253                                 // }
 254                         }
 255
 256                         case IJavaElement.PACKAGE_FRAGMENT:
 257                                 return getPackageFragmentIcon(element, renderFlags);
 258
 259                         case IJavaElement.COMPILATION_UNIT:
 260                                 return PHPUiImages.DESC_OBJS_CUNIT;
 261
 262                         case IJavaElement.CLASS_FILE:
 263                                 /*
 264                                  * this is too expensive for large packages try { IClassFile
 265                                  * cfile= (IClassFile)element; if (cfile.isClass()) return
 266                                  * PHPUiImages.IMG_OBJS_CFILECLASS; return
 267                                  * PHPUiImages.IMG_OBJS_CFILEINT; } catch(JavaModelException e) { //
 268                                  * fall through; }
 269                                  */
 270                                 return PHPUiImages.DESC_OBJS_CFILE;
 271
 272                         case IJavaElement.JAVA_PROJECT:
 273                                 IJavaProject jp = (IJavaProject) element;
 274                                 if (jp.getProject().isOpen()) {
 275                                         IProject project = jp.getProject();
 276                                         IWorkbenchAdapter adapter = (IWorkbenchAdapter) project
 277                                                         .getAdapter(IWorkbenchAdapter.class);
 278                                         if (adapter != null) {
 279                                                 ImageDescriptor result = adapter
 280                                                                 .getImageDescriptor(project);
 281                                                 if (result != null)
 282                                                         return result;
 283                                         }
 284                                         return DESC_OBJ_PROJECT;
 285                                 }
 286                                 return DESC_OBJ_PROJECT_CLOSED;
 287
 288                         case IJavaElement.JAVA_MODEL:
 289                                 return PHPUiImages.DESC_OBJS_JAVA_MODEL;
 290                         }
 291
 292                         Assert.isTrue(false, PHPUIMessages
 293                                         .getString("JavaImageLabelprovider.assert.wrongImage")); //$NON-NLS-1$
 294                         return null; //$NON-NLS-1$
 295
 296                 } catch (JavaModelException e) {
 297                         if (e.isDoesNotExist())
 298                                 return PHPUiImages.DESC_OBJS_UNKNOWN;
 299                         PHPeclipsePlugin.log(e);
 300                         return PHPUiImages.DESC_OBJS_GHOST;
 301                 }
 302         }
 303
 304         protected ImageDescriptor getPackageFragmentIcon(IJavaElement element,
 305                         int renderFlags) throws JavaModelException {
 306                 // IPackageFragment fragment= (IPackageFragment)element;
 307                 // boolean containsJavaElements= false;
 308                 // try {
 309                 // containsJavaElements= fragment.hasChildren();
 310                 // } catch(JavaModelException e) {
 311                 // // assuming no children;
 312                 // }
 313                 // if(!containsJavaElements && (fragment.getNonJavaResources().length >
 314                 // 0))
 315                 // return PHPUiImages.DESC_OBJS_EMPTY_PACKAGE_RESOURCES;
 316                 // else if (!containsJavaElements)
 317                 // return PHPUiImages.DESC_OBJS_EMPTY_PACKAGE;
 318                 return PHPUiImages.DESC_OBJS_PACKAGE;
 319         }
 320
 321         public void dispose() {
 322         }
 323
 324         // ---- Methods to compute the adornments flags
 325         // ---------------------------------
 326
 327         private int computeJavaAdornmentFlags(IJavaElement element, int renderFlags) {
 328                 int flags = 0;
 329                 if (showOverlayIcons(renderFlags) && element instanceof IMember) {
 330                         try {
 331                                 IMember member = (IMember) element;
 332
 333                                 if (element.getElementType() == IJavaElement.METHOD
 334                                                 && ((IMethod) element).isConstructor())
 335                                         flags |= JavaElementImageDescriptor.CONSTRUCTOR;
 336
 337                                 int modifiers = member.getFlags();
 338                                 if (Flags.isAbstract(modifiers) && confirmAbstract(member))
 339                                         flags |= JavaElementImageDescriptor.ABSTRACT;
 340                                 if (Flags.isFinal(modifiers) || isInterfaceField(member))
 341                                         flags |= JavaElementImageDescriptor.FINAL;
 342                                 // if (Flags.isSynchronized(modifiers) &&
 343                                 // confirmSynchronized(member))
 344                                 // flags |= JavaElementImageDescriptor.SYNCHRONIZED;
 345                                 if (Flags.isStatic(modifiers) || isInterfaceField(member))
 346                                         flags |= JavaElementImageDescriptor.STATIC;
 347
 348                                 // if (member.getElementType() == IJavaElement.TYPE) {
 349                                 // if (JavaModelUtil.hasMainMethod((IType) member)) {
 350                                 // flags |= JavaElementImageDescriptor.RUNNABLE;
 351                                 // }
 352                                 // }
 353                         } catch (JavaModelException e) {
 354                                 // do nothing. Can't compute runnable adornment or get flags
 355                         }
 356                 }
 357                 return flags;
 358         }
 359
 360         private static boolean confirmAbstract(IMember element)
 361                         throws JavaModelException {
 362                 // never show the abstract symbol on interfaces or members in interfaces
 363                 if (element.getElementType() == IJavaElement.TYPE) {
 364                         return ((IType) element).isClass();
 365                 }
 366                 return element.getDeclaringType().isClass();
 367         }
 368
 369         private static boolean isInterfaceField(IMember element)
 370                         throws JavaModelException {
 371                 // always show the final && static symbol on interface fields
 372                 if (element.getElementType() == IJavaElement.FIELD) {
 373                         return element.getDeclaringType().isInterface();
 374                 }
 375                 return false;
 376         }
 377
 378 //      private static boolean confirmSynchronized(IJavaElement member) {
 379 //              // Synchronized types are allowed but meaningless.
 380 //              return member.getElementType() != IJavaElement.TYPE;
 381 //      }
 382
 383         public static ImageDescriptor getMethodImageDescriptor(
 384                         boolean isInInterface, int flags) {
 385                 if (Flags.isPublic(flags) || isInInterface)
 386                         return PHPUiImages.DESC_MISC_PUBLIC;
 387                 if (Flags.isProtected(flags))
 388                         return PHPUiImages.DESC_MISC_PROTECTED;
 389                 if (Flags.isPrivate(flags))
 390                         return PHPUiImages.DESC_MISC_PRIVATE;
 391
 392                 return PHPUiImages.DESC_MISC_DEFAULT;
 393         }
 394
 395         public static ImageDescriptor getFieldImageDescriptor(
 396                         boolean isInInterface, int flags) {
 397                 if (Flags.isPublic(flags) || isInInterface)
 398                         return PHPUiImages.DESC_FIELD_PUBLIC;
 399                 if (Flags.isProtected(flags))
 400                         return PHPUiImages.DESC_FIELD_PROTECTED;
 401                 if (Flags.isPrivate(flags))
 402                         return PHPUiImages.DESC_FIELD_PRIVATE;
 403
 404                 return PHPUiImages.DESC_FIELD_DEFAULT;
 405         }
 406
 407         public static ImageDescriptor getTypeImageDescriptor(boolean isInterface,
 408                         boolean isInner, int flags) {
 409                 if (isInner) {
 410                         if (isInterface) {
 411                                 return getInnerInterfaceImageDescriptor(flags);
 412                         } else {
 413                                 return getInnerClassImageDescriptor(flags);
 414                         }
 415                 } else {
 416                         if (isInterface) {
 417                                 return getInterfaceImageDescriptor(flags);
 418                         } else {
 419                                 return getClassImageDescriptor(flags);
 420                         }
 421                 }
 422         }
 423
 424         private static ImageDescriptor getClassImageDescriptor(int flags) {
 425                 if (Flags.isPublic(flags) || Flags.isProtected(flags)
 426                                 || Flags.isPrivate(flags))
 427                         return PHPUiImages.DESC_OBJS_CLASS;
 428                 else
 429                         return PHPUiImages.DESC_OBJS_CLASS_DEFAULT;
 430         }
 431
 432         private static ImageDescriptor getInnerClassImageDescriptor(int flags) {
 433                 if (Flags.isPublic(flags))
 434                         return PHPUiImages.DESC_OBJS_INNER_CLASS_PUBLIC;
 435                 else if (Flags.isPrivate(flags))
 436                         return PHPUiImages.DESC_OBJS_INNER_CLASS_PRIVATE;
 437                 else if (Flags.isProtected(flags))
 438                         return PHPUiImages.DESC_OBJS_INNER_CLASS_PROTECTED;
 439                 else
 440                         return PHPUiImages.DESC_OBJS_INNER_CLASS_DEFAULT;
 441         }
 442
 443         private static ImageDescriptor getInterfaceImageDescriptor(int flags) {
 444                 if (Flags.isPublic(flags) || Flags.isProtected(flags)
 445                                 || Flags.isPrivate(flags))
 446                         return PHPUiImages.DESC_OBJS_INTERFACE;
 447                 else
 448                         return PHPUiImages.DESC_OBJS_INTERFACE_DEFAULT;
 449         }
 450
 451         private static ImageDescriptor getInnerInterfaceImageDescriptor(int flags) {
 452                 if (Flags.isPublic(flags))
 453                         return PHPUiImages.DESC_OBJS_INNER_INTERFACE_PUBLIC;
 454                 else if (Flags.isPrivate(flags))
 455                         return PHPUiImages.DESC_OBJS_INNER_INTERFACE_PRIVATE;
 456                 else if (Flags.isProtected(flags))
 457                         return PHPUiImages.DESC_OBJS_INNER_INTERFACE_PROTECTED;
 458                 else
 459                         return PHPUiImages.DESC_OBJS_INTERFACE_DEFAULT;
 460         }
 461 }