| /******************************************************************************* |
| * Copyright (c) 2000, 2006 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.ui.internal.decorators; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Set; |
| import java.util.StringTokenizer; |
| |
| import org.eclipse.core.runtime.IConfigurationElement; |
| import org.eclipse.core.runtime.IExtension; |
| import org.eclipse.core.runtime.IExtensionPoint; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.ListenerList; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.dynamichelpers.ExtensionTracker; |
| import org.eclipse.core.runtime.dynamichelpers.IExtensionChangeHandler; |
| import org.eclipse.core.runtime.dynamichelpers.IExtensionTracker; |
| import org.eclipse.jface.util.SafeRunnable; |
| import org.eclipse.jface.viewers.DecorationContext; |
| import org.eclipse.jface.viewers.IBaseLabelProvider; |
| import org.eclipse.jface.viewers.IColorDecorator; |
| import org.eclipse.jface.viewers.IDecorationContext; |
| import org.eclipse.jface.viewers.IDelayedLabelDecorator; |
| import org.eclipse.jface.viewers.IFontDecorator; |
| import org.eclipse.jface.viewers.ILabelDecorator; |
| import org.eclipse.jface.viewers.ILabelProviderListener; |
| import org.eclipse.jface.viewers.ILightweightLabelDecorator; |
| import org.eclipse.jface.viewers.LabelDecorator; |
| import org.eclipse.jface.viewers.LabelProviderChangedEvent; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.ui.IDecoratorManager; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.internal.IPreferenceConstants; |
| import org.eclipse.ui.internal.LegacyResourceSupport; |
| import org.eclipse.ui.internal.Workbench; |
| import org.eclipse.ui.internal.WorkbenchMessages; |
| import org.eclipse.ui.internal.WorkbenchPlugin; |
| import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants; |
| import org.eclipse.ui.internal.util.PrefUtil; |
| import org.eclipse.ui.internal.util.Util; |
| import org.eclipse.ui.progress.WorkbenchJob; |
| |
| /** |
| * The DecoratorManager is the class that handles all of the |
| * decorators defined in the image. |
| * |
| * @since 2.0 |
| */ |
| public class DecoratorManager extends LabelDecorator implements IDelayedLabelDecorator, |
| ILabelProviderListener, IDecoratorManager, IFontDecorator, IColorDecorator, IExtensionChangeHandler { |
| |
| private static String EXTENSIONPOINT_UNIQUE_ID = WorkbenchPlugin.PI_WORKBENCH + "." + IWorkbenchRegistryConstants.PL_DECORATORS; //$NON-NLS-1$ |
| |
| /** |
| * The family for the decorate job. |
| */ |
| public static final Object FAMILY_DECORATE = new Object(); |
| |
| private DecorationScheduler scheduler; |
| |
| private LightweightDecoratorManager lightweightManager; |
| |
| //Hold onto the list of listeners to be told if a change has occured |
| private ListenerList listeners = new ListenerList(); |
| |
| //The full definitions read from the registry. |
| //Initalize to an empty collection as this is rarely used now. |
| private FullDecoratorDefinition[] fullDefinitions; |
| |
| private FullTextDecoratorRunnable fullTextRunnable = new FullTextDecoratorRunnable(); |
| |
| private FullImageDecoratorRunnable fullImageRunnable = new FullImageDecoratorRunnable(); |
| |
| private static final FullDecoratorDefinition[] EMPTY_FULL_DEF = new FullDecoratorDefinition[0]; |
| |
| private final String PREFERENCE_SEPARATOR = ","; //$NON-NLS-1$ |
| |
| private final String VALUE_SEPARATOR = ":"; //$NON-NLS-1$ |
| |
| private final String P_TRUE = "true"; //$NON-NLS-1$ |
| |
| private final String P_FALSE = "false"; //$NON-NLS-1$ |
| |
| /** |
| * Create a new instance of the receiver and load the |
| * settings from the installed plug-ins. |
| */ |
| public DecoratorManager() { |
| |
| scheduler = new DecorationScheduler(this); |
| IExtensionTracker tracker = PlatformUI.getWorkbench() |
| .getExtensionTracker(); |
| tracker.registerHandler(this, ExtensionTracker.createExtensionPointFilter(getExtensionPointFilter())); |
| } |
| |
| /** |
| * Initalize the decorator definitions. |
| */ |
| private void initializeDecoratorDefinitions() { |
| DecoratorRegistryReader reader = new DecoratorRegistryReader(); |
| Collection values = reader |
| .readRegistry(Platform.getExtensionRegistry()); |
| |
| ArrayList full = new ArrayList(); |
| ArrayList lightweight = new ArrayList(); |
| Iterator allDefinitions = values.iterator(); |
| IExtensionTracker configurationElementTracker = PlatformUI |
| .getWorkbench().getExtensionTracker(); |
| while (allDefinitions.hasNext()) { |
| DecoratorDefinition nextDefinition = (DecoratorDefinition) allDefinitions |
| .next(); |
| if (nextDefinition.isFull()) { |
| full.add(nextDefinition); |
| } else { |
| lightweight.add(nextDefinition); |
| } |
| |
| configurationElementTracker.registerObject(nextDefinition.getConfigurationElement().getDeclaringExtension(), nextDefinition, IExtensionTracker.REF_WEAK); |
| } |
| |
| fullDefinitions = new FullDecoratorDefinition[full.size()]; |
| full.toArray(fullDefinitions); |
| |
| LightweightDecoratorDefinition[] lightweightDefinitions = new LightweightDecoratorDefinition[lightweight |
| .size()]; |
| lightweight.toArray(lightweightDefinitions); |
| |
| lightweightManager = new LightweightDecoratorManager( |
| lightweightDefinitions); |
| |
| applyDecoratorsPreference(); |
| } |
| |
| /** |
| * For dynamic UI |
| * |
| * @param definition the definition to add |
| * @since 3.0 |
| */ |
| public void addDecorator(DecoratorDefinition definition) { |
| if (definition.isFull()) { |
| if (getFullDecoratorDefinition(definition.getId()) == null) { |
| FullDecoratorDefinition[] oldDefs = getFullDefinitions(); |
| fullDefinitions = new FullDecoratorDefinition[fullDefinitions.length + 1]; |
| System |
| .arraycopy(oldDefs, 0, fullDefinitions, 0, |
| oldDefs.length); |
| fullDefinitions[oldDefs.length] = (FullDecoratorDefinition) definition; |
| clearCaches(); |
| updateForEnablementChange(); |
| } |
| } else { |
| if (getLightweightManager().addDecorator( |
| (LightweightDecoratorDefinition) definition)) { |
| clearCaches(); |
| updateForEnablementChange(); |
| } |
| } |
| ((Workbench) PlatformUI.getWorkbench()) |
| .getExtensionTracker().registerObject( |
| definition.getConfigurationElement().getDeclaringExtension(), definition, IExtensionTracker.REF_WEAK); |
| } |
| |
| /** |
| * See if the supplied decorator cache has a value for the |
| * element. If not calculate it from the enabledDefinitions and |
| * update the cache. |
| * @return Collection of DecoratorDefinition. |
| * @param element The element being tested. |
| * @param enabledDefinitions The definitions currently defined for this decorator. |
| */ |
| static Collection getDecoratorsFor(Object element, |
| DecoratorDefinition[] enabledDefinitions) { |
| |
| ArrayList decorators = new ArrayList(); |
| |
| for (int i = 0; i < enabledDefinitions.length; i++) { |
| if (enabledDefinitions[i].isEnabledFor(element)) { |
| decorators.add(enabledDefinitions[i]); |
| } |
| } |
| |
| return decorators; |
| |
| } |
| |
| |
| /** |
| * Add the listener to the list of listeners. |
| */ |
| public void addListener(ILabelProviderListener listener) { |
| listeners.add(listener); |
| } |
| |
| /** |
| * Remove the listener from the list. |
| */ |
| public void removeListener(ILabelProviderListener listener) { |
| listeners.remove(listener); |
| scheduler.listenerRemoved(listener); |
| } |
| |
| /** |
| * Get the list of elements listening to the receiver. |
| * @return ILabelProviderListener [] |
| */ |
| ILabelProviderListener [] getListeners(){ |
| Object[] array = listeners.getListeners(); |
| ILabelProviderListener [] listenerArray = |
| new ILabelProviderListener [array.length]; |
| System.arraycopy(array,0,listenerArray,0,listenerArray.length); |
| return listenerArray; |
| } |
| |
| /** |
| * Inform all of the listeners that require an update |
| * @param listener The listener we are updating. |
| * @param event |
| * the event with the update details |
| */ |
| void fireListener(final LabelProviderChangedEvent event, final ILabelProviderListener listener) { |
| Platform.run(new SafeRunnable() { |
| public void run() { |
| listener.labelProviderChanged(event); |
| } |
| }); |
| |
| } |
| |
| /** |
| * Inform all of the listeners that require an update |
| * @param event the event with the update details |
| */ |
| void fireListeners(final LabelProviderChangedEvent event) { |
| Object[] array = listeners.getListeners(); |
| for (int i = 0; i < array.length; i++) { |
| final ILabelProviderListener l = (ILabelProviderListener) array[i]; |
| Platform.run(new SafeRunnable() { |
| public void run() { |
| l.labelProviderChanged(event); |
| } |
| }); |
| } |
| } |
| |
| /** |
| * Fire any listeners from the UIThread. Used for cases where this |
| * may be invoked outside of the UI by the public API. |
| * @param event the event with the update details |
| */ |
| void fireListenersInUIThread(final LabelProviderChangedEvent event) { |
| |
| //No updates if there is no UI |
| if (!PlatformUI.isWorkbenchRunning()) { |
| return; |
| } |
| |
| //Only bother with the job if in the UI Thread |
| if (Thread.currentThread() == PlatformUI.getWorkbench().getDisplay() |
| .getThread()) { |
| fireListeners(event); |
| return; |
| } |
| |
| WorkbenchJob updateJob = new WorkbenchJob(WorkbenchMessages.DecorationScheduler_UpdateJobName) { |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.progress.UIJob#runInUIThread(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public IStatus runInUIThread(IProgressMonitor monitor) { |
| fireListeners(event); |
| return Status.OK_STATUS; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.core.runtime.jobs.Job#belongsTo(java.lang.Object) |
| */ |
| public boolean belongsTo(Object family) { |
| return FAMILY_DECORATE == family; |
| } |
| }; |
| updateJob.setSystem(true); |
| updateJob.schedule(); |
| |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.viewers.ILabelDecorator2#decorateText(java.lang.String, java.lang.Object, org.eclipse.jface.viewers.IDecorationContext) |
| */ |
| public String decorateText(String text, Object element, IDecorationContext context) { |
| //Get any adaptations to IResource |
| Object adapted = getResourceAdapter(element); |
| String result = scheduler.decorateWithText(text, element, adapted, context); |
| FullDecoratorDefinition[] decorators = getDecoratorsFor(element); |
| for (int i = 0; i < decorators.length; i++) { |
| if (decorators[i].isEnabledFor(element)) { |
| String newResult = safeDecorateText(element, result, |
| decorators[i]); |
| if (newResult != null) { |
| result = newResult; |
| } |
| } |
| } |
| |
| if (adapted != null) { |
| decorators = getDecoratorsFor(adapted); |
| for (int i = 0; i < decorators.length; i++) { |
| if (decorators[i].isAdaptable() |
| && decorators[i].isEnabledFor(adapted)) { |
| String newResult = safeDecorateText(adapted, result, |
| decorators[i]); |
| if (newResult != null) { |
| result = newResult; |
| } |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jface.viewers.ILabelDecorator#decorateText(java.lang.String, java.lang.Object) |
| */ |
| public String decorateText(String text, Object element) { |
| return decorateText(text, element, DecorationContext.DEFAULT_CONTEXT); |
| } |
| |
| /** |
| * Decorate the text in a SafeRunnable. |
| * @param element The element we are decorating |
| * @param start The currently decorated String |
| * @param decorator The decorator to run. |
| * @param context the decoration context |
| * @return String |
| */ |
| private String safeDecorateText(Object element, String start, |
| FullDecoratorDefinition decorator) { |
| fullTextRunnable.setValues(start, element, decorator); |
| Platform.run(fullTextRunnable); |
| String newResult = fullTextRunnable.getResult(); |
| return newResult; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.viewers.ILabelDecorator2#decorateImage(org.eclipse.swt.graphics.Image, java.lang.Object, org.eclipse.jface.viewers.IDecorationContext) |
| */ |
| public Image decorateImage(Image image, Object element, IDecorationContext context) { |
| Object adapted = getResourceAdapter(element); |
| Image result = scheduler.decorateWithOverlays(image, element, adapted, context); |
| FullDecoratorDefinition[] decorators = getDecoratorsFor(element); |
| |
| for (int i = 0; i < decorators.length; i++) { |
| if (decorators[i].isEnabledFor(element)) { |
| Image newResult = safeDecorateImage(element, result, |
| decorators[i]); |
| if (newResult != null) { |
| result = newResult; |
| } |
| } |
| } |
| |
| //Get any adaptations to IResource |
| |
| if (adapted != null) { |
| decorators = getDecoratorsFor(adapted); |
| for (int i = 0; i < decorators.length; i++) { |
| if (decorators[i].isAdaptable() |
| && decorators[i].isEnabledFor(adapted)) { |
| Image newResult = safeDecorateImage(adapted, result, |
| decorators[i]); |
| if (newResult != null) { |
| result = newResult; |
| } |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jface.viewers.ILabelDecorator#decorateImage(org.eclipse.swt.graphics.Image, java.lang.Object) |
| */ |
| public Image decorateImage(Image image, Object element) { |
| return decorateImage(image, element, DecorationContext.DEFAULT_CONTEXT); |
| } |
| |
| /** |
| * Decorate the image in a SafeRunnable. |
| * @param element The element we are decorating |
| * @param start The currently decorated Image |
| * @param decorator The decorator to run. |
| * @param context The decoration context |
| * @return Image |
| */ |
| private Image safeDecorateImage(Object element, Image start, |
| FullDecoratorDefinition decorator) { |
| fullImageRunnable.setValues(start, element, decorator); |
| Platform.run(fullImageRunnable); |
| Image newResult = fullImageRunnable.getResult(); |
| return newResult; |
| } |
| |
| /** |
| * Get the resource adapted object for the supplied |
| * element. Return <code>null</code>. if there isn't one. |
| * @param element |
| * @return Object or <code>null</code>. |
| */ |
| private Object getResourceAdapter(Object element) { |
| Object adapted = LegacyResourceSupport.getAdaptedContributorResource(element); |
| if (adapted != element) { |
| return adapted; //Avoid applying decorator twice |
| } |
| return null; |
| } |
| |
| /** |
| * Return whether or not the decorator registered for element |
| * has a label property called property name. |
| */ |
| public boolean isLabelProperty(Object element, String property) { |
| return isLabelProperty(element, property, true); |
| } |
| |
| /** |
| * Return whether or not the decorator registered for element |
| * has a label property called property name. |
| * Check for an adapted resource if checkAdapted is true. |
| * @param element |
| * @param property |
| * @param checkAdapted |
| * @return boolean <code>true</code> if there is a label property |
| * for element or its adapted value |
| */ |
| public boolean isLabelProperty(Object element, String property, |
| boolean checkAdapted) { |
| boolean fullCheck = isLabelProperty(element, property, |
| getDecoratorsFor(element)); |
| |
| if (fullCheck) { |
| return fullCheck; |
| } |
| |
| boolean lightweightCheck = isLabelProperty(element, property, |
| getLightweightManager().getDecoratorsFor(element)); |
| |
| if (lightweightCheck) { |
| return true; |
| } |
| |
| if (checkAdapted) { |
| //Get any adaptions to IResource |
| Object adapted = getResourceAdapter(element); |
| if (adapted == null || adapted == element) { |
| return false; |
| } |
| |
| fullCheck = isLabelProperty(adapted, property, |
| getDecoratorsFor(adapted)); |
| if (fullCheck) { |
| return fullCheck; |
| } |
| |
| return isLabelProperty(adapted, property, lightweightManager |
| .getDecoratorsFor(adapted)); |
| } |
| return false; |
| } |
| |
| private boolean isLabelProperty(Object element, String property, |
| DecoratorDefinition[] decorators) { |
| for (int i = 0; i < decorators.length; i++) { |
| if (decorators[i].isEnabledFor(element) |
| && decorators[i].isLabelProperty(element, property)) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Return the enabled full decorator definitions. |
| * @return FullDecoratorDefinition[] |
| */ |
| private FullDecoratorDefinition[] enabledFullDefinitions() { |
| |
| FullDecoratorDefinition[] full = getFullDefinitions(); |
| //As this are a deprecated data type optimize for |
| //the undefined case. |
| if(full.length == 0) { |
| return full; |
| } |
| ArrayList result = new ArrayList(); |
| for (int i = 0; i < full.length; i++) { |
| if (full[i].isEnabled()) { |
| result.add(full[i]); |
| } |
| } |
| FullDecoratorDefinition[] returnArray = new FullDecoratorDefinition[result |
| .size()]; |
| result.toArray(returnArray); |
| return returnArray; |
| } |
| |
| /* |
| * @see IBaseLabelProvider#dispose() |
| */ |
| public void dispose() { |
| //do nothing |
| } |
| |
| /** |
| * Clear the caches in the manager. This is required |
| * to avoid updates that may occur due to changes in |
| * enablement. |
| */ |
| public void clearCaches() { |
| getLightweightManager().reset(); |
| fullTextRunnable.clearReferences(); |
| fullImageRunnable.clearReferences(); |
| } |
| |
| /** |
| * Enablement had changed. Fire the listeners and write |
| * the preference. |
| */ |
| public void updateForEnablementChange() { |
| //Clear any results that may be around as all labels have changed |
| scheduler.clearResults(); |
| fireListenersInUIThread(new LabelProviderChangedEvent(this)); |
| writeDecoratorsPreference(); |
| } |
| |
| /** |
| * Get the DecoratorDefinitions defined on the receiver. |
| * @return DecoratorDefinition[] |
| */ |
| public DecoratorDefinition[] getAllDecoratorDefinitions() { |
| LightweightDecoratorDefinition[] lightweightDefinitions = getLightweightManager() |
| .getDefinitions(); |
| DecoratorDefinition[] returnValue = new DecoratorDefinition[fullDefinitions.length |
| + lightweightDefinitions.length]; |
| System.arraycopy(fullDefinitions, 0, returnValue, 0, |
| fullDefinitions.length); |
| System.arraycopy(lightweightDefinitions, 0, returnValue, |
| fullDefinitions.length, lightweightDefinitions.length); |
| return returnValue; |
| } |
| |
| /* |
| * @see ILabelProviderListener#labelProviderChanged(LabelProviderChangedEvent) |
| */ |
| public void labelProviderChanged(LabelProviderChangedEvent event) { |
| Object[] elements = event.getElements(); |
| scheduler.clearResults(); |
| //If the elements are not specified send out a general update |
| if (elements == null) { |
| fireListeners(event); |
| } else { |
| //Assume that someone is going to care about the |
| //decoration result and just start it right away |
| for (int i = 0; i < elements.length; i++) { |
| Object adapted = getResourceAdapter(elements[i]); |
| //Force an update in case full decorators are the only ones enabled |
| scheduler.queueForDecoration(elements[i], adapted, true, null, DecorationContext.DEFAULT_CONTEXT); |
| } |
| } |
| } |
| |
| /** |
| * Store the currently enabled decorators in |
| * preference store. |
| */ |
| private void writeDecoratorsPreference() { |
| StringBuffer enabledIds = new StringBuffer(); |
| writeDecoratorsPreference(enabledIds, getFullDefinitions()); |
| writeDecoratorsPreference(enabledIds, getLightweightManager() |
| .getDefinitions()); |
| |
| WorkbenchPlugin.getDefault().getPreferenceStore().setValue( |
| IPreferenceConstants.ENABLED_DECORATORS, enabledIds.toString()); |
| PrefUtil.savePrefs(); |
| } |
| |
| private void writeDecoratorsPreference(StringBuffer enabledIds, |
| DecoratorDefinition[] definitions) { |
| for (int i = 0; i < definitions.length; i++) { |
| enabledIds.append(definitions[i].getId()); |
| enabledIds.append(VALUE_SEPARATOR); |
| if (definitions[i].isEnabled()) { |
| enabledIds.append(P_TRUE); |
| } else { |
| enabledIds.append(P_FALSE); |
| } |
| |
| enabledIds.append(PREFERENCE_SEPARATOR); |
| } |
| } |
| |
| /** |
| * Get the currently enabled decorators in |
| * preference store and set the state of the |
| * current definitions accordingly. |
| */ |
| public void applyDecoratorsPreference() { |
| |
| String preferenceValue = WorkbenchPlugin.getDefault() |
| .getPreferenceStore().getString( |
| IPreferenceConstants.ENABLED_DECORATORS); |
| |
| StringTokenizer tokenizer = new StringTokenizer(preferenceValue, |
| PREFERENCE_SEPARATOR); |
| Set enabledIds = new HashSet(); |
| Set disabledIds = new HashSet(); |
| while (tokenizer.hasMoreTokens()) { |
| String nextValuePair = tokenizer.nextToken(); |
| |
| //Strip out the true or false to get the id |
| String id = nextValuePair.substring(0, nextValuePair |
| .indexOf(VALUE_SEPARATOR)); |
| if (nextValuePair.endsWith(P_TRUE)) { |
| enabledIds.add(id); |
| } else { |
| disabledIds.add(id); |
| } |
| } |
| |
| FullDecoratorDefinition[] full = getFullDefinitions(); |
| for (int i = 0; i < full.length; i++) { |
| String id = full[i].getId(); |
| if (enabledIds.contains(id)) { |
| full[i].setEnabled(true); |
| } else { |
| if (disabledIds.contains(id)) { |
| full[i].setEnabled(false); |
| } |
| } |
| } |
| |
| LightweightDecoratorDefinition[] lightweightDefinitions = getLightweightManager() |
| .getDefinitions(); |
| for (int i = 0; i < lightweightDefinitions.length; i++) { |
| String id = lightweightDefinitions[i].getId(); |
| if (enabledIds.contains(id)) { |
| lightweightDefinitions[i].setEnabled(true); |
| } else { |
| if (disabledIds.contains(id)) { |
| lightweightDefinitions[i].setEnabled(false); |
| } |
| } |
| } |
| |
| } |
| |
| /** |
| * Shutdown the decorator manager by disabling all |
| * of the decorators so that dispose() will be called |
| * on them. |
| */ |
| public void shutdown() { |
| //Disable all of the enabled decorators |
| //so as to force a dispose of thier decorators |
| FullDecoratorDefinition[] full = getFullDefinitions(); |
| for (int i = 0; i < full.length; i++) { |
| if (full[i].isEnabled()) { |
| full[i].setEnabled(false); |
| } |
| } |
| if(lightweightManager != null) { |
| getLightweightManager().shutdown(); |
| } |
| scheduler.shutdown(); |
| dispose(); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IDecoratorManager#getEnabled(java.lang.String) |
| */ |
| public boolean getEnabled(String decoratorId) { |
| DecoratorDefinition definition = getDecoratorDefinition(decoratorId); |
| if (definition == null) { |
| return false; |
| } |
| return definition.isEnabled(); |
| } |
| |
| /** |
| * @see IDecoratorManager#getLabelDecorator() |
| */ |
| public ILabelDecorator getLabelDecorator() { |
| return this; |
| } |
| |
| /** |
| * @see IDecoratorManager#setEnabled(String, boolean) |
| */ |
| public void setEnabled(String decoratorId, boolean enabled) { |
| DecoratorDefinition definition = getDecoratorDefinition(decoratorId); |
| if (definition != null) { |
| definition.setEnabled(enabled); |
| clearCaches(); |
| updateForEnablementChange(); |
| } |
| } |
| |
| /* |
| * @see IDecoratorManager#getBaseLabelProvider(String) |
| */ |
| public IBaseLabelProvider getBaseLabelProvider(String decoratorId) { |
| IBaseLabelProvider fullProvider = getLabelDecorator(decoratorId); |
| if (fullProvider == null) { |
| return getLightweightLabelDecorator(decoratorId); |
| } |
| return fullProvider; |
| } |
| |
| /* |
| * @see IDecoratorManager#getLabelDecorator(String) |
| */ |
| public ILabelDecorator getLabelDecorator(String decoratorId) { |
| FullDecoratorDefinition definition = getFullDecoratorDefinition(decoratorId); |
| |
| //Do not return for a disabled decorator |
| if (definition != null && definition.isEnabled()) { |
| return definition.getDecorator(); |
| } |
| return null; |
| } |
| |
| /* |
| * @see IDecoratorManager#getLightweightLabelDecorator(String) |
| */ |
| public ILightweightLabelDecorator getLightweightLabelDecorator( |
| String decoratorId) { |
| LightweightDecoratorDefinition definition = getLightweightManager() |
| .getDecoratorDefinition(decoratorId); |
| //Do not return for a disabled decorator |
| if (definition != null && definition.isEnabled()) { |
| return definition.getDecorator(); |
| } |
| return null; |
| } |
| |
| /** |
| * Get the DecoratorDefinition with the supplied id |
| * @return DecoratorDefinition or <code>null</code> if it is not found |
| * @param decoratorId String |
| */ |
| private DecoratorDefinition getDecoratorDefinition(String decoratorId) { |
| DecoratorDefinition returnValue = getFullDecoratorDefinition(decoratorId); |
| if (returnValue == null) { |
| return getLightweightManager().getDecoratorDefinition(decoratorId); |
| } |
| return returnValue; |
| } |
| |
| /** |
| * Get the FullDecoratorDefinition with the supplied id |
| * @return FullDecoratorDefinition or <code>null</code> if it is not found |
| * @param decoratorId the id |
| */ |
| private FullDecoratorDefinition getFullDecoratorDefinition( |
| String decoratorId) { |
| int idx = getFullDecoratorDefinitionIdx(decoratorId); |
| if (idx != -1) { |
| return getFullDefinitions()[idx]; |
| } |
| return null; |
| } |
| |
| /** |
| * Return the index of the definition in the array. |
| * |
| * @param decoratorId the id |
| * @return the index of the definition in the array or <code>-1</code> |
| * @since 3.1 |
| */ |
| private int getFullDecoratorDefinitionIdx( |
| String decoratorId) { |
| FullDecoratorDefinition[] full = getFullDefinitions(); |
| for (int i = 0; i < full.length; i++) { |
| if (full[i].getId().equals(decoratorId)) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| |
| /** |
| * Get the full decorator definitions registered for elements of this type. |
| * @param element The element to look up |
| * @return FullDecoratorDefinition[] |
| */ |
| private FullDecoratorDefinition[] getDecoratorsFor(Object element) { |
| |
| if (element == null) { |
| return EMPTY_FULL_DEF; |
| } |
| |
| Collection decorators = getDecoratorsFor(element, |
| enabledFullDefinitions()); |
| FullDecoratorDefinition[] decoratorArray = EMPTY_FULL_DEF; |
| if (decorators.size() > 0){ |
| decoratorArray = new FullDecoratorDefinition[decorators.size()]; |
| decorators.toArray(decoratorArray); |
| } |
| |
| return decoratorArray; |
| } |
| |
| /** |
| * Returns the lightweightManager. This method is |
| * public for use by test cases. No other classes outside of |
| * this package should use this method. |
| * @return LightweightDecoratorManager |
| */ |
| public LightweightDecoratorManager getLightweightManager() { |
| if(lightweightManager == null) { |
| initializeDecoratorDefinitions(); |
| } |
| return lightweightManager; |
| } |
| |
| /** |
| * @see org.eclipse.ui.IDecoratorManager#update(java.lang.String) |
| */ |
| public void update(String decoratorId) { |
| |
| IBaseLabelProvider provider = getBaseLabelProvider(decoratorId); |
| if (provider != null) { |
| scheduler.clearResults(); |
| fireListeners(new LabelProviderChangedEvent(provider)); |
| } |
| |
| } |
| |
| public boolean prepareDecoration(Object element, String originalText, IDecorationContext context) { |
| // Check if there is a decoration ready or if there is no lightweight decorators to be applied |
| if (scheduler.isDecorationReady(element, context) |
| || !getLightweightManager().hasEnabledDefinitions()) { |
| return true; |
| } |
| |
| // Force an update if there is a text already |
| boolean force = true; |
| //If not then do not force as the undecorated value is fine |
| if(originalText == null || originalText.length() == 0) { |
| force = false; |
| } |
| |
| // Queue the decoration. |
| scheduler.queueForDecoration(element, getResourceAdapter(element), |
| force, originalText, context); |
| |
| //If all that is there is deferred ones then defer decoration. |
| //For the sake of efficiency we do not test for enablement at this |
| //point and just abandon deferment if there are any to run right |
| //away |
| return getFullDefinitions().length > 0; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.viewers.IDelayedLabelDecorator#prepareDecoration(java.lang.Object, java.lang.String) |
| */ |
| public boolean prepareDecoration(Object element, String originalText) { |
| return prepareDecoration(element, originalText, DecorationContext.DEFAULT_CONTEXT); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.viewers.IFontDecorator#decorateFont(java.lang.Object) |
| */ |
| public Font decorateFont(Object element) { |
| return scheduler.getFont(element, getResourceAdapter(element)); |
| } |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.viewers.IColorDecorator#decorateBackground(java.lang.Object) |
| */ |
| public Color decorateBackground(Object element) { |
| return scheduler.getBackgroundColor(element, getResourceAdapter(element)); |
| } |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.viewers.IColorDecorator#decorateForeground(java.lang.Object) |
| */ |
| public Color decorateForeground(Object element) { |
| return scheduler.getForegroundColor(element, getResourceAdapter(element)); |
| } |
| /** |
| * Get all of the defined fullDefinitions. Initalize if |
| * required |
| * @return FullDecoratorDefinition[] |
| */ |
| private FullDecoratorDefinition[] getFullDefinitions() { |
| if(fullDefinitions == null) { |
| initializeDecoratorDefinitions(); |
| } |
| return fullDefinitions; |
| } |
| |
| private IExtensionPoint getExtensionPointFilter() { |
| return Platform.getExtensionRegistry().getExtensionPoint(EXTENSIONPOINT_UNIQUE_ID); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.core.runtime.dynamicHelpers.IExtensionChangeHandler#addExtension(org.eclipse.core.runtime.dynamicHelpers.IExtensionTracker, org.eclipse.core.runtime.IExtension) |
| */ |
| public void addExtension(IExtensionTracker tracker, IExtension addedExtension) { |
| IConfigurationElement addedElements[] = addedExtension.getConfigurationElements(); |
| for (int i = 0; i < addedElements.length; i++) { |
| DecoratorRegistryReader reader = new DecoratorRegistryReader(); |
| reader.readElement(addedElements[i]); |
| for (Iterator j = reader.getValues().iterator(); j.hasNext();) { |
| addDecorator((DecoratorDefinition) j.next()); |
| } |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.core.runtime.dynamicHelpers.IExtensionChangeHandler#removeExtension(org.eclipse.core.runtime.IExtension, java.lang.Object[]) |
| */ |
| public void removeExtension(IExtension source, Object[] objects) { |
| |
| boolean shouldClear = false; |
| for (int i = 0; i < objects.length; i++) { |
| if (objects[i] instanceof DecoratorDefinition) { |
| DecoratorDefinition definition = (DecoratorDefinition) objects[i]; |
| if (definition.isFull()) { |
| int idx = getFullDecoratorDefinitionIdx(definition.getId()); |
| if (idx != -1) { |
| FullDecoratorDefinition[] oldDefs = getFullDefinitions(); |
| Util |
| .arrayCopyWithRemoval( |
| oldDefs, |
| fullDefinitions = new FullDecoratorDefinition[fullDefinitions.length - 1], |
| idx); |
| shouldClear = true; |
| } |
| } else { |
| shouldClear |= getLightweightManager().removeDecorator( |
| (LightweightDecoratorDefinition) definition); |
| } |
| } |
| } |
| |
| if(shouldClear){ |
| clearCaches(); |
| updateForEnablementChange(); |
| } |
| |
| } |
| |
| } |
