case-study/jdt-after/ui/org/eclipse/jdt/internal/ui/viewsupport/JavaUILabelProvider.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2011 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 java.util.ArrayList;
  14
  15 import org.eclipse.swt.graphics.Color;
  16 import org.eclipse.swt.graphics.Image;
  17
  18 import org.eclipse.core.runtime.ListenerList;
  19 import org.eclipse.core.runtime.SafeRunner;
  20
  21 import org.eclipse.core.resources.IStorage;
  22
  23 import org.eclipse.jface.util.SafeRunnable;
  24 import org.eclipse.jface.viewers.IColorProvider;
  25 import org.eclipse.jface.viewers.ILabelDecorator;
  26 import org.eclipse.jface.viewers.ILabelProvider;
  27 import org.eclipse.jface.viewers.ILabelProviderListener;
  28 import org.eclipse.jface.viewers.LabelProviderChangedEvent;
  29 import org.eclipse.jface.viewers.StyledCellLabelProvider;
  30 import org.eclipse.jface.viewers.StyledString;
  31 import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider.IStyledLabelProvider;
  32
  33 import org.eclipse.jdt.core.ICompilationUnit;
  34 import org.eclipse.jdt.core.IJavaElement;
  35 import org.eclipse.jdt.core.IType;
  36
  37 import org.eclipse.jdt.ui.JavaElementLabels;
  38
  39 import org.eclipse.jdt.internal.ui.javaeditor.JavaEditorErrorTickUpdater;
  40 import org.eclipse.jdt.internal.ui.typehierarchy.TypeHierarchyViewPart;
  41
  42 public class JavaUILabelProvider implements ILabelProvider, IColorProvider, IStyledLabelProvider {
  43
  44         protected ListenerList fListeners = new ListenerList();
  45
  46         protected JavaElementImageProvider fImageLabelProvider;
  47         protected StorageLabelProvider fStorageLabelProvider;
  48
  49         private ArrayList<ILabelDecorator> fLabelDecorators;
  50
  51         private int fImageFlags;
  52         private long fTextFlags;
  53
  54         /**
  55          * Creates a new label provider with default flags.
  56          */
  57         public JavaUILabelProvider() {
  58                 this(JavaElementLabels.ALL_DEFAULT, JavaElementImageProvider.OVERLAY_ICONS);
  59         }
  60
  61         /**
  62          * @param textFlags Flags defined in <code>JavaElementLabels</code>.
  63          * @param imageFlags Flags defined in <code>JavaElementImageProvider</code>.
  64          */
  65         public JavaUILabelProvider(long textFlags, int imageFlags) {
  66                 fImageLabelProvider= new JavaElementImageProvider();
  67                 fLabelDecorators= null;
  68
  69                 fStorageLabelProvider= new StorageLabelProvider();
  70                 fImageFlags= imageFlags;
  71                 fTextFlags= textFlags;
  72         }
  73
  74         /**
  75          * Adds a decorator to the label provider
  76          * @param decorator the decorator to add
  77          */
  78         public void addLabelDecorator(ILabelDecorator decorator) {
  79                 if (fLabelDecorators == null) {
  80                         fLabelDecorators= new ArrayList<ILabelDecorator>(2);
  81                 }
  82                 fLabelDecorators.add(decorator);
  83         }
  84
  85         /**
  86          * Sets the textFlags.
  87          * @param textFlags The textFlags to set
  88          */
  89         public final void setTextFlags(long textFlags) {
  90                 fTextFlags= textFlags;
  91         }
  92
  93         /**
  94          * Sets the imageFlags
  95          * @param imageFlags The imageFlags to set
  96          */
  97         public final void setImageFlags(int imageFlags) {
  98                 fImageFlags= imageFlags;
  99         }
 100
 101         /**
 102          * Gets the image flags.
 103          * Can be overwritten by super classes.
 104          * @return Returns a int
 105          */
 106         public final int getImageFlags() {
 107                 return fImageFlags;
 108         }
 109
 110         /**
 111          * Gets the text flags.
 112          * @return Returns a int
 113          */
 114         public final long getTextFlags() {
 115                 return fTextFlags;
 116         }
 117
 118         /**
 119          * Evaluates the image flags for a element.
 120          * Can be overwritten by super classes.
 121          * @param element the element to compute the image flags for
 122          * @return Returns a int
 123          */
 124         protected int evaluateImageFlags(Object element) {
 125                 return getImageFlags();
 126         }
 127
 128         /**
 129          * Evaluates the text flags for a element. Can be overwritten by super classes.
 130          * @param element the element to compute the text flags for
 131          * @return Returns a int
 132          */
 133         protected long evaluateTextFlags(Object element) {
 134                 return getTextFlags();
 135         }
 136
 137         protected Image decorateImage(Image image, Object element) {
 138                 if (fLabelDecorators != null && image != null) {
 139                         for (int i= 0; i < fLabelDecorators.size(); i++) {
 140                                 ILabelDecorator decorator= fLabelDecorators.get(i);
 141                                 image= decorator.decorateImage(image, element);
 142                         }
 143                 }
 144                 return image;
 145         }
 146
 147         /* (non-Javadoc)
 148          * @see ILabelProvider#getImage
 149          */
 150         public Image getImage(Object element) {
 151                 Image result= fImageLabelProvider.getImageLabel(element, evaluateImageFlags(element));
 152                 if (result == null && (element instanceof IStorage)) {
 153                         result= fStorageLabelProvider.getImage(element);
 154                 }
 155
 156                 return decorateImage(result, element);
 157         }
 158
 159         protected String decorateText(String text, Object element) {
 160                 if (fLabelDecorators != null && text.length() > 0) {
 161                         for (int i= 0; i < fLabelDecorators.size(); i++) {
 162                                 ILabelDecorator decorator= fLabelDecorators.get(i);
 163                                 String decorated= decorator.decorateText(text, element);
 164                                 if (decorated != null) {
 165                                         text= decorated;
 166                                 }
 167                         }
 168                 }
 169                 return text;
 170         }
 171
 172
 173         /* (non-Javadoc)
 174          * @see ILabelProvider#getText
 175          */
 176         public String getText(Object element) {
 177                 String result= JavaElementLabels.getTextLabel(element, evaluateTextFlags(element));
 178                 if (result.length() == 0 && (element instanceof IStorage)) {
 179                         result= fStorageLabelProvider.getText(element);
 180                 }
 181                 return decorateText(result, element);
 182         }
 183
 184         public StyledString getStyledText(Object element) {
 185                 StyledString string= JavaElementLabels.getStyledTextLabel(element, (evaluateTextFlags(element) | JavaElementLabels.COLORIZE));
 186                 if (string.length() == 0 && (element instanceof IStorage)) {
 187                         string= new StyledString(fStorageLabelProvider.getText(element));
 188                 }
 189                 String decorated= decorateText(string.getString(), element);
 190                 if (decorated != null) {
 191                         return StyledCellLabelProvider.styleDecoratedString(decorated, StyledString.DECORATIONS_STYLER, string);
 192                 }
 193                 return string;
 194         }
 195
 196         /* (non-Javadoc)
 197          * @see IBaseLabelProvider#dispose
 198          */
 199         public void dispose() {
 200                 if (fLabelDecorators != null) {
 201                         for (int i= 0; i < fLabelDecorators.size(); i++) {
 202                                 ILabelDecorator decorator= fLabelDecorators.get(i);
 203                                 decorator.dispose();
 204                         }
 205                         fLabelDecorators= null;
 206                 }
 207                 fStorageLabelProvider.dispose();
 208                 fImageLabelProvider.dispose();
 209         }
 210
 211         /* (non-Javadoc)
 212          * @see IBaseLabelProvider#addListener(ILabelProviderListener)
 213          */
 214         public void addListener(ILabelProviderListener listener) {
 215                 if (fLabelDecorators != null) {
 216                         for (int i= 0; i < fLabelDecorators.size(); i++) {
 217                                 ILabelDecorator decorator= fLabelDecorators.get(i);
 218                                 decorator.addListener(listener);
 219                         }
 220                 }
 221                 fListeners.add(listener);
 222         }
 223
 224         /* (non-Javadoc)
 225          * @see IBaseLabelProvider#isLabelProperty(Object, String)
 226          */
 227         public boolean isLabelProperty(Object element, String property) {
 228                 return true;
 229         }
 230
 231         /* (non-Javadoc)
 232          * @see IBaseLabelProvider#removeListener(ILabelProviderListener)
 233          */
 234         public void removeListener(ILabelProviderListener listener) {
 235                 if (fLabelDecorators != null) {
 236                         for (int i= 0; i < fLabelDecorators.size(); i++) {
 237                                 ILabelDecorator decorator= fLabelDecorators.get(i);
 238                                 decorator.removeListener(listener);
 239                         }
 240                 }
 241                 fListeners.remove(listener);
 242         }
 243
 244         public static ILabelDecorator[] getDecorators(boolean errortick, ILabelDecorator extra) {
 245                 if (errortick) {
 246                         if (extra == null) {
 247                                 return new ILabelDecorator[] {};
 248                         } else {
 249                                 return new ILabelDecorator[] { extra };
 250                         }
 251                 }
 252                 if (extra != null) {
 253                         return new ILabelDecorator[] { extra };
 254                 }
 255                 return null;
 256         }
 257
 258         /* (non-Javadoc)
 259          * @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
 260          */
 261         public Color getForeground(Object element) {
 262                 return null;
 263         }
 264
 265         /* (non-Javadoc)
 266          * @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
 267          */
 268         public Color getBackground(Object element) {
 269                 return null;
 270         }
 271
 272     /**
 273      * Fires a label provider changed event to all registered listeners
 274      * Only listeners registered at the time this method is called are notified.
 275      *
 276      * @param event a label provider changed event
 277      *
 278      * @see ILabelProviderListener#labelProviderChanged
 279      */
 280     protected void fireLabelProviderChanged(final LabelProviderChangedEvent event) {
 281         Object[] listeners = fListeners.getListeners();
 282         for (int i = 0; i < listeners.length; ++i) {
 283             final ILabelProviderListener l = (ILabelProviderListener) listeners[i];
 284             SafeRunner.run(new SafeRunnable() {
 285                 public void run() {
 286                     l.labelProviderChanged(event);
 287                 }
 288             });
 289         }
 290     }
 291
 292         public void generated_8215432148921187727(JavaEditorErrorTickUpdater javaeditorerrortickupdater, IJavaElement jelement, Image titleImage) {
 293                 Image newImage;
 294                 if (jelement instanceof ICompilationUnit && !jelement.getJavaProject().isOnClasspath(jelement))
 295                         newImage= getImage(jelement.getResource());
 296                 else
 297                         newImage= getImage(jelement);
 298                 if (titleImage != newImage) {
 299                         javaeditorerrortickupdater.postImageChange(newImage);
 300                 }
 301         }
 302
 303         public void generated_9074807705238785340(TypeHierarchyViewPart typehierarchyviewpart, final IType input) {
 304                 typehierarchyviewpart.fMethodViewerPaneLabel.setText(getText(input));
 305                 typehierarchyviewpart.fMethodViewerPaneLabel.setImage(getImage(input));
 306         }
 307
 308
 309 }