/*******************************************************************************
* Copyright (c) 2005, 2017 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
*
*******************************************************************************/
package org.eclipse.dltk.ui.viewsupport;
import java.util.ArrayList;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.IDLTKLanguageToolkit;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.internal.ui.UIModelProviderManager;
import org.eclipse.dltk.ui.ScriptElementImageProvider;
import org.eclipse.dltk.ui.ScriptElementLabels;
import org.eclipse.jface.resource.CompositeImageDescriptor;
import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider.IStyledLabelProvider;
import org.eclipse.jface.viewers.IColorProvider;
import org.eclipse.jface.viewers.ILabelDecorator;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.LabelProviderChangedEvent;
import org.eclipse.jface.viewers.StyledCellLabelProvider;
import org.eclipse.jface.viewers.StyledString;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.Point;
public class ScriptUILabelProvider
implements ILabelProvider, IColorProvider, IStyledLabelProvider {
protected ListenerList<ILabelProviderListener> fListeners = new ListenerList<>(
1);
protected ScriptElementImageProvider fImageLabelProvider;
protected StorageLabelProvider fStorageLabelProvider;
private int fImageFlags;
private long fTextFlags;
private ArrayList<ILabelDecorator> fLabelDecorators;
/**
* Creates a new label provider with default flags.
*/
public ScriptUILabelProvider() {
this(ScriptElementLabels.ALL_DEFAULT,
ScriptElementImageProvider.OVERLAY_ICONS);
fLabelDecorators = null;
}
/**
* @param textFlags
* Flags defined in <code>ScriptElementLabels</code>.
* @param imageFlags
* Flags defined in <code>ScriptElementImageProvider</code>.
*/
public ScriptUILabelProvider(long textFlags, int imageFlags) {
fImageLabelProvider = new ScriptElementImageProvider();
fStorageLabelProvider = new StorageLabelProvider();
fImageFlags = imageFlags;
fTextFlags = textFlags;
fLabelDecorators = null;
}
public final void setTextFlags(long textFlags) {
fTextFlags = textFlags;
}
public final void setImageFlags(int imageFlags) {
fImageFlags = imageFlags;
}
public final int getImageFlags() {
return fImageFlags;
}
public final long getTextFlags() {
return fTextFlags;
}
/**
* Evaluates the image flags for a element. Can be overwriten by super
* classes.
*
* @return Returns a int
*/
protected int evaluateImageFlags(Object element) {
return getImageFlags();
}
/**
* Evaluates the text flags for a element. Can be overwriten by super
* classes.
*
* @return Returns a int
*/
protected long evaluateTextFlags(Object element) {
return getTextFlags();
}
@Override
public Image getImage(Object element) {
ILabelProvider[] providers = getProviders(element);
final int flags = evaluateImageFlags(element);
Image result = null;
if (providers != null) {
for (int i = 0; i < providers.length; i++) {
Image image = providers[i].getImage(element);
if (image != null) {
if (ScriptElementImageProvider.useSmallSize(flags)) {
result = image;
} else {
result = getLocalRegistry().get(new BigImageDescriptor(
image, ScriptElementImageProvider.BIG_SIZE));
}
break;
}
}
}
if (result == null) {
result = fImageLabelProvider.getImageLabel(element, flags);
}
if (result == null && (element instanceof IStorage
|| element instanceof ISourceModule)) {
result = fStorageLabelProvider.getImage(element);
// StorageLabelProvider always returns 16x16 images
// resize if this provider returns big icons
if (result != null
&& !ScriptElementImageProvider.useSmallSize(flags)) {
result = getLocalRegistry().get(new BigImageDescriptor(result,
ScriptElementImageProvider.BIG_SIZE));
}
}
return decorateImage(result, element);
}
private static class BigImageDescriptor extends CompositeImageDescriptor {
private final Point fSize;
private final Image fBaseImage;
public BigImageDescriptor(Image baseImage, Point size) {
fBaseImage = baseImage;
Assert.isNotNull(fBaseImage);
fSize = size;
Assert.isNotNull(fSize);
}
@Override
protected Point getSize() {
return fSize;
}
@Override
public boolean equals(Object object) {
if (object == null
|| !BigImageDescriptor.class.equals(object.getClass())) {
return false;
}
BigImageDescriptor other = (BigImageDescriptor) object;
return fBaseImage.equals(other.fBaseImage)
&& fSize.equals(other.fSize);
}
@Override
public int hashCode() {
return fBaseImage.hashCode() ^ fSize.hashCode();
}
@Override
protected void drawCompositeImage(int width, int height) {
ImageData bg = this.fBaseImage.getImageData();
if (bg != null) {
drawImage(bg, 0, 0);
}
}
}
private ImageDescriptorRegistry localRegistry = null;
private ImageDescriptorRegistry getLocalRegistry() {
if (localRegistry == null) {
localRegistry = new ImageDescriptorRegistry(false);
}
return localRegistry;
}
@Override
public String getText(Object element) {
StyledString styledText = getStyledText(element);
if (styledText != null)
return styledText.toString();
return null;
}
private ILabelProvider[] getProviders(Object element) {
String idtoolkit = null;
if (element instanceof IModelElement) {
IDLTKLanguageToolkit toolkit = DLTKLanguageManager
.getLanguageToolkit((IModelElement) element);
if (toolkit != null) {
idtoolkit = toolkit.getNatureId();
}
}
ILabelProvider[] providers = UIModelProviderManager
.getLabelProviders(idtoolkit);
return providers;
}
@Override
public void addListener(ILabelProviderListener listener) {
if (fLabelDecorators != null) {
for (int i = 0; i < fLabelDecorators.size(); i++) {
ILabelDecorator decorator = fLabelDecorators.get(i);
decorator.addListener(listener);
}
}
fListeners.add(listener);
}
@Override
public void dispose() {
if (fLabelDecorators != null) {
for (int i = 0; i < fLabelDecorators.size(); i++) {
ILabelDecorator decorator = fLabelDecorators.get(i);
decorator.dispose();
}
fLabelDecorators = null;
}
if (localRegistry != null) {
localRegistry.dispose();
localRegistry = null;
}
fStorageLabelProvider.dispose();
fImageLabelProvider.dispose();
}
@Override
public boolean isLabelProperty(Object element, String property) {
return true;
}
@Override
public void removeListener(ILabelProviderListener listener) {
if (fLabelDecorators != null) {
for (int i = 0; i < fLabelDecorators.size(); i++) {
ILabelDecorator decorator = fLabelDecorators.get(i);
decorator.removeListener(listener);
}
}
fListeners.remove(listener);
}
@Override
public Color getForeground(Object element) {
return null;
}
@Override
public Color getBackground(Object element) {
return null;
}
/**
* Fires a label provider changed event to all registered listeners Only
* listeners registered at the time this method is called are notified.
*
* @param event
* a label provider changed event
*
* @see ILabelProviderListener#labelProviderChanged
*/
protected void fireLabelProviderChanged(
final LabelProviderChangedEvent event) {
for (final ILabelProviderListener l : fListeners) {
SafeRunner.run(new SafeRunnable() {
@Override
public void run() {
l.labelProviderChanged(event);
}
});
}
}
public void addLabelDecorator(ILabelDecorator decorator) {
if (fLabelDecorators == null) {
fLabelDecorators = new ArrayList<>(2);
}
fLabelDecorators.add(decorator);
}
protected Image decorateImage(Image image, Object element) {
if (fLabelDecorators != null && image != null) {
for (int i = 0; i < fLabelDecorators.size(); i++) {
ILabelDecorator decorator = fLabelDecorators.get(i);
image = decorator.decorateImage(image, element);
}
}
return image;
}
protected String decorateText(String text, Object element) {
if (fLabelDecorators != null && text.length() > 0) {
for (int i = 0; i < fLabelDecorators.size(); i++) {
ILabelDecorator decorator = fLabelDecorators.get(i);
text = decorator.decorateText(text, element);
}
}
return text;
}
/**
* @since 5.2
*/
@Override
public StyledString getStyledText(Object element) {
ILabelProvider[] providers = getProviders(element);
StyledString result = null;
if (providers != null) {
for (int i = 0; i < providers.length; i++) {
if (providers[i] instanceof IStyledLabelProvider) {
StyledString string = ((IStyledLabelProvider) providers[i])
.getStyledText(element);
if (string != null) {
result = string;
break;
}
} else {
String text = providers[i].getText(element);
if (text != null) {
result = new StyledString(text);
break;
}
}
}
}
if (result == null) {
result = new StyledString(ScriptElementLabels.getDefault()
.getTextLabel(element, evaluateTextFlags(element)));
}
if (result.length() == 0 && (element instanceof IStorage)) {
result = new StyledString(fStorageLabelProvider.getText(element));
}
String decorated = decorateText(result.getString(), element);
if (decorated != null) {
return StyledCellLabelProvider.styleDecoratedString(decorated,
StyledString.DECORATIONS_STYLER, result);
}
return result;
}
}