import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.IHandler;

		private StyledString getStyledString(Object element, IStyledLabelProvider provider) {

			StyledString string= provider.getStyledText(element);

			if (selectionDecorator != null && isSelected(element)) {

				String decorated= selectionDecorator.decorateText(string.getString(), element);

				return new StyledString(decorated); // no need to add colors when element is selected

			}

			return string;

		}

		public void update(ViewerCell cell) {

			Object element= cell.getElement();

			if (!(element instanceof ItemsListSeparator) && provider instanceof IStyledLabelProvider) {

				IStyledLabelProvider styledLabelProvider= (IStyledLabelProvider) provider;

				StyledString styledString= getStyledString(element, styledLabelProvider);

				cell.setText(styledString.getString());

				cell.setStyleRanges(styledString.getStyleRanges());

				cell.setImage(styledLabelProvider.getImage(element));

			} else {

				cell.setText(getText(element));

				cell.setImage(getImage(element));

			}

			cell.setFont(getFont(element));

			cell.setForeground(getForeground(element));

			cell.setBackground(getBackground(element));

			super.update(cell);

		}

		private boolean isSelected(Object element) {

			int[] selectionIndices = list.getTable().getSelectionIndices();

			List elements = Arrays

					.asList(contentProvider.getElements(null));

			for (int i = 0; i < selectionIndices.length; i++) {

				if (elements.size() > selectionIndices[i]

						&& element

								.equals(elements.get(selectionIndices[i]))) {

					return true;

				}

			}

			return false;

		}

	/**

	 * Returns the location and bounds of the area where the image is drawn.

	 * 

	 * @param index

	 *            the column index

	 * @return the bounds of the of the image area. May return <code>null</code>

	 *         if the underlying widget implementation doesn't provide this

	 *         information

	 * @since 3.4

	 */

	public Rectangle getImageBounds(int index) {

		return null;

	}

 * 

 * @deprecated Will be removed before 3.4 M6. Use {@link StyledCellLabelProvider} instead.

 * 

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.ViewerRow#getImageBounds(int)

	 */

	public Rectangle getImageBounds(int index) {

		return item.getImageBounds(index);

	}

import org.eclipse.swt.custom.StyleRange;

	private static final String KEY_TEXT_LAYOUT = "styled_label_key_"; //$NON-NLS-1$

	/**

	 * Set the style ranges to be applied on the text label

	 * Note: Requires {@link StyledCellLabelProvider} with owner draw enabled.

	 * 

	 * @param styleRanges the styled ranges

	 * 

	 * @since 3.4

	 */

	public void setStyleRanges(StyleRange[] styleRanges) {

		getItem().setData(KEY_TEXT_LAYOUT + columnIndex, styleRanges);

	}

	/**

	 * Returns the style ranges to be applied on the text label or <code>null</code> if no

	 * style ranges have been set.

	 * 

	 * @return styleRanges the styled ranges

	 * 

	 * @since 3.4

	 */

	public StyleRange[] getStyleRanges() {

		return (StyleRange[]) getItem().getData(KEY_TEXT_LAYOUT + columnIndex);

	}

	/**

	 * Returns the location and bounds of the area where the image is drawn 

	 * 

	 * @return The bounds of the of the image area. May return <code>null</code>

	 *         if the underlying widget implementation doesn't provide this

	 *         information

	 * @since 3.4

	 */

	public Rectangle getImageBounds() {

		return row.getImageBounds(columnIndex);

	}

	/**

	 * Gets the foreground color of the cell.

	 * 

	 * @return the foreground of the cell or <code>null</code> for the default foreground

	 * 

	 * @since 3.4

	 */

	public Color getForeground() {

		return row.getForeground(columnIndex);

	}

	/**

	 * Gets the background color of the cell.

	 * 

	 * @return the background of the cell or <code>null</code> for the default background

	 * 

	 * @since 3.4

	 */

	public Color getBackground() {

		return row.getBackground(columnIndex);

	}

	/**

	 * Gets the font of the cell.

	 * 

	 * @return the font of the cell or <code>null</code> for the default font

	 * 

	 * @since 3.4

	 */

	public Font getFont() {

		return row.getFont(columnIndex);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.ViewerRow#getImageBounds(int)

	 */

	public Rectangle getImageBounds(int index) {

		return item.getImageBounds(index);

	}	

    /**

     * Identifier for the color used to show extra informations in labels, as a qualified name.

     * For example in 'Foo.txt - myproject/bar', the qualifier is '- myproject/bar'.

     * 

     * @since 3.4

     */

	public static final String QUALIFIER_COLOR= "QUALIFIER_COLOR"; //$NON-NLS-1$

    /**

     * Identifier for the color used to show label decorations

     * For example in 'Foo.txt [1.16]', the decoration is '[1.16]'.

     * 

     * @since 3.4

     */

	public static final String DECORATIONS_COLOR= "DECORATIONS_COLOR"; //$NON-NLS-1$

    /**

     * Identifier for the color used to counter informations

     * For example in 'Foo.txt (2 matches)', the counter information is '(2 matches)'.

     * 

     * @since 3.4

     */

	public static final String COUNTER_COLOR= "COUNTER_COLOR"; //$NON-NLS-1$

/*******************************************************************************

 * Copyright (c) 2008 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.jface.viewers;

import org.eclipse.swt.graphics.Image;

/**

 * A {@link DelegatingStyledCellLabelProvider} is a {@link StyledCellLabelProvider}

 * that delegates requests for styled string and the imaged

 * to a {@link DelegatingStyledCellLabelProvider.IStyledLabelProvider}.

 * 

 * <p>Existing label providers can be enhanced by implementing

 * {@link DelegatingStyledCellLabelProvider.IStyledLabelProvider}, and are then cable of being

 *  used in viewer with styled labels.</p>

 * 

 * <p>The {@link DelegatingStyledCellLabelProvider.IStyledLabelProvider} can

 * optionally implement {@link IColorProvider} and {@link IFontProvider} to provide

 * foreground and background color and a default font.

 * </p>

 * 

 * 

 * @since 3.4

 */

public class DelegatingStyledCellLabelProvider extends StyledCellLabelProvider {

	/**

	 * Interface marking a label provider that provides styled text labels and images.

	 * <p>The {@link DelegatingStyledCellLabelProvider.IStyledLabelProvider} can

	 * optionally implement {@link IColorProvider} and {@link IFontProvider} to provide

	 * foreground and background color and a default font.

	 * </p>

	 */

	public static interface IStyledLabelProvider extends IBaseLabelProvider {

		/**

		 * Returns the styled text label for the given element

		 * 

		 * @param element the element to evaluate the styled string for

		 * 

		 * @return the styled string.

		 */

		public StyledString getStyledText(Object element);

	    /**

	     * Returns the image for the label of the given element.  The image

	     * is owned by the label provider and must not be disposed directly.

	     * Instead, dispose the label provider when no longer needed.

	     *

	     * @param element the element for which to provide the label image

	     * @return the image used to label the element, or <code>null</code>

	     *   if there is no image for the given object

	     */

	    public Image getImage(Object element);

	}

	private IStyledLabelProvider styledLabelProvider;

	/**

	 * Creates a {@link DelegatingStyledCellLabelProvider} that delegates the requests for

	 * styled labels and for images to a {@link IStyledLabelProvider}.

	 * 

	 * @param labelProvider the label provider

	 */

	public DelegatingStyledCellLabelProvider(IStyledLabelProvider labelProvider) {

		styledLabelProvider= labelProvider;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.StyledCellLabelProvider#update(org.eclipse.jface.viewers.ViewerCell)

	 */

	public void update(ViewerCell cell) {

		Object element= cell.getElement();

		StyledString styledString= styledLabelProvider.getStyledText(element);

		cell.setText(styledString.getString());

		cell.setImage(styledLabelProvider.getImage(element));

		if (isOwnerDrawEnabled()) {

			cell.setStyleRanges(styledString.getStyleRanges());

		} else {

			cell.setStyleRanges(null);

		}

		if (styledLabelProvider instanceof IFontProvider) {

			cell.setFont(((IFontProvider) styledLabelProvider).getFont(element));

		}

		if (styledLabelProvider instanceof IColorProvider) {

			IColorProvider colorProvider= (IColorProvider) styledLabelProvider;

			cell.setForeground(colorProvider.getForeground(element));

			cell.setBackground(colorProvider.getBackground(element));

		}

		super.update(cell);

	}

	/**

	 * Returns the styled string provider.

	 * 

	 * @return  the wrapped label provider

	 */

	public IStyledLabelProvider getStyledStringProvider() {

		return styledLabelProvider;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.BaseLabelProvider#addListener(org.eclipse.jface.viewers.ILabelProviderListener)

	 */

	public void addListener(ILabelProviderListener listener) {

		super.addListener(listener);

		styledLabelProvider.addListener(listener);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.BaseLabelProvider#removeListener(org.eclipse.jface.viewers.ILabelProviderListener)

	 */

	public void removeListener(ILabelProviderListener listener) {

		super.removeListener(listener);

		styledLabelProvider.removeListener(listener);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.StyledCellLabelProvider#dispose()

	 */

	public void dispose() {

		super.dispose();

		styledLabelProvider.dispose();

	}

}

/*******************************************************************************

 * Copyright (c) 2008 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.jface.viewers;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.jface.preference.JFacePreferences;

import org.eclipse.jface.resource.ColorRegistry;

import org.eclipse.jface.resource.JFaceResources;

import org.eclipse.swt.custom.StyleRange;

import org.eclipse.swt.graphics.TextStyle;

/**

 * Represents a string with styled ranges. All ranges mark substrings of the string and do not overlap.

 * Styles are represented by {@link Style}.

 * 

 * The styled string can be modified:

 * <ul>

 * <li>new strings with styles can be appended</li>

 * <li>styles can by applied to to the existing string</li>

 * </ul>

 * 

 * <p>

 * This class may be instantiated; it is not intended to be subclassed.

 * </p>

 *  @since 3.4

 */

public class StyledString {

	/**

	 * Represents a style that can be associated to one ore more ranges in the {@link StyledString}

	 *  

	 */

	public static abstract class Style {

		/**

		 * Applies the styles represented by this object to the given textStyle.

		 * 

		 * @param textStyle the {@link TextStyle} to modify

		 */

		public abstract void applyStyles(TextStyle textStyle);

	}

	/**

	 * A built-in style using the {@link JFacePreferences#QUALIFIER_COLOR} 

	 * managed in the JFace color registry (See {@link JFaceResources#getColorRegistry()}).

	 */

	public static final Style QUALIFIER_STYLE= createColorRegistryStyle(JFacePreferences.QUALIFIER_COLOR, null);

	/**

	 * A built-in style using the {@link JFacePreferences#COUNTER_COLOR} 

	 * managed in the JFace color registry (See {@link JFaceResources#getColorRegistry()}).

	 */	

	public static final Style COUNTER_STYLE= createColorRegistryStyle(JFacePreferences.COUNTER_COLOR, null);

	/**

	 * A built-in style using the {@link JFacePreferences#DECORATIONS_COLOR} 

	 * managed in the JFace color registry (See {@link JFaceResources#getColorRegistry()}).

	 */

	public static final Style DECORATIONS_STYLE= createColorRegistryStyle(JFacePreferences.DECORATIONS_COLOR, null); 

	/**

	 * Creates a style that takes the given foreground and background colors from the JFace color registry.

	 * 

	 * @param foregroundColorName the color name for the foreground color

	 * @param backgroundColorName the color name for the background color

	 * 

	 * @return the created style

	 */

	public static Style createColorRegistryStyle(String foregroundColorName, String backgroundColorName) {

		return new DefaultStyle(foregroundColorName, backgroundColorName); 

	}

	private static final StyleRange[] EMPTY= new StyleRange[0];

	private StringBuffer fBuffer;

	private StyleRunList fStyleRuns;

	/**

	 * Creates an empty {@link StyledString}.

	 */

	public StyledString() {

		fBuffer= new StringBuffer();

		fStyleRuns= null;

	}

	/**

	 * Creates an {@link StyledString} initialized with a string without a style associated.

	 * 

	 * @param string the string 

	 */

	public StyledString(String string) {

		this(string, null);

	}

	/**

	 * Creates an {@link StyledString} initialized with a string and a style.  

	 * 

	 * @param string the string 

	 * @param style the style of the text or <code>null</code> to not associated a style.

	 */

	public StyledString(String string, Style style) {

		this();

		append(string, style);

	}

	/**

	 * Returns the string of this {@link StyledString}.

	 * 

	 * @return the current string of this {@link StyledString}.

	 */

	public String getString() {

		return fBuffer.toString();

	}

	/**

	 * Returns the length of the string of this {@link StyledString}.

	 * 

	 * @return the length of the current string

	 */

	public int length() {

		return fBuffer.length();

	}

	/**

	 * Appends a string to the {@link StyledString}. The appended string will have no style associated.

	 * 

	 * @param string the string to append.

	 * @return returns a reference to this object.

	 */

	public StyledString append(String string) {

		return append(string, null);

	}

	/**

	 * Appends a character to the {@link StyledString}. The appended character will have no style associated.

	 * 

	 * @param ch the character to append.

	 * @return returns a reference to this object.

	 */

	public StyledString append(char ch) {

		return append(String.valueOf(ch), null);

	}

	/**

	 * Appends a string with styles to the {@link StyledString}.

	 * 

	 * @param string the string to append.

	 * @return returns a reference to this object.

	 */

	public StyledString append(StyledString string) {

		if (string.length() == 0) {

			return this;

		}

		int offset= fBuffer.length();

		fBuffer.append(string.getString());

		List otherRuns= string.fStyleRuns;

		if (otherRuns != null && !otherRuns.isEmpty()) {

			for (int i= 0; i < otherRuns.size(); i++) {

				StyleRun curr= (StyleRun) otherRuns.get(i);

				if (i == 0 && curr.offset != 0) {

					appendStyleRun(null, offset); // appended string will start with the default color

				}

				appendStyleRun(curr.style, offset + curr.offset);

			}

		} else {

			appendStyleRun(null, offset); // appended string will start with the default color

		}

		return this;

	}

	/**

	 * Appends a character with a style to the {@link StyledString}. The appended character will

	 * have the given style associated.

	 * 

	 * @param ch the character to append.

	 * @param style the style to of the character to append or <code>null</code> if no style should be

	 * associated to the string.

	 * @return returns a reference to this object.

	 */

	public StyledString append(char ch, Style style) {

		return append(String.valueOf(ch), style);

	}

	/**

	 * Appends a string with a style to the {@link StyledString}. The appended string will

	 * have the given style associated.

	 * 

	 * @param string the string to append.

	 * @param style the style to of the string to append or <code>null</code> if no style should be

	 * associated to the string.

	 * @return returns a reference to this object.

	 */

	public StyledString append(String string, Style style) {

		if (string.length() == 0)

			return this;

		int offset= fBuffer.length(); // the length before appending

		fBuffer.append(string);

		appendStyleRun(style, offset);

		return this;

	}

	/**

	 * Sets a style to the given source range. The range must be subrange of actual string of this {@link StyledString}.

	 * Styles previously set for that range will be overwritten.

	 * 

	 * @param offset the start offset of the range

	 * @param length the length of the range

	 * @param style the style to set

	 * 

	 * @throws StringIndexOutOfBoundsException if <code>start</code> is

     *             less than zero, or if offset plus length is greater than the length of this object.

	 */

	public void setStyle(int offset, int length, Style style) {

		if (offset < 0 || offset + length > fBuffer.length()) {

			throw new StringIndexOutOfBoundsException("Invalid offset (" + offset + ") or length (" + length + ")");   //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$

		}

		if (length == 0) {

			return;

		}

		if (!hasRuns() || getLastRun().offset <= offset) {

			appendStyleRun(style, offset);

			if (offset + length != fBuffer.length()) {

				appendStyleRun(null, offset + length);

			}

			return;

		}

		int endRun= findRun(offset + length);

		if (endRun >= 0) {

			// run with the same end index, nothing to change

		} else {

			endRun= -(endRun + 1);

			if (offset + length < fBuffer.length()) {

				Style prevStyle= endRun > 0 ? fStyleRuns.getRun(endRun - 1).style : null;

				fStyleRuns.add(endRun, new StyleRun(offset + length, prevStyle));

			}

		}

		int startRun= findRun(offset);

		if (startRun >= 0) {

			// run with the same start index

			StyleRun styleRun= fStyleRuns.getRun(startRun);

			styleRun.style= style;

		} else {

			startRun= -(startRun + 1);

			Style prevStyle= startRun > 0 ? fStyleRuns.getRun(startRun - 1).style : null;

			if (isDifferentStyle(prevStyle, style) || (startRun == 0 && style != null)) {

				fStyleRuns.add(startRun, new StyleRun(offset, style));

				endRun++; // endrun is moved one back

			} else {

				startRun--; // we use the previous

			}

		}

		if (startRun + 1 < endRun) {

			fStyleRuns.removeRange(startRun + 1, endRun);

		}

	}

	/**

	 * Returns {@link StyleRange} for all applied styles to this string

	 * 

	 * @return an array of all {@link StyleRange} applied to this string.

	 */

	public StyleRange[] getStyleRanges() {

		if (hasRuns()) {

			ArrayList res= new ArrayList();

			List styleRuns= getStyleRuns();

			int offset= 0;

			Style style= null;

			for (int i= 0; i < styleRuns.size(); i++) {

				StyleRun curr= (StyleRun) styleRuns.get(i);

				if (isDifferentStyle(curr.style, style)) {

					if (curr.offset > offset && style != null) {

						res.add(createStyleRange(offset, curr.offset, style));

					}

					offset= curr.offset;

					style= curr.style;

				}

			}

			if (fBuffer.length() > offset && style != null) {

				res.add(createStyleRange(offset, fBuffer.length(), style));

			}

			return (StyleRange[]) res.toArray(new StyleRange[res.size()]);

		}

		return EMPTY;

	}

	private int findRun(int offset) {

		// method assumes that fStyleRuns is not null

		int low= 0;

		int high= fStyleRuns.size() - 1;

		while (low <= high) {

		    int mid = (low + high) / 2;

		    StyleRun styleRun= fStyleRuns.getRun(mid);

		    if (styleRun.offset < offset) {

		    	low = mid + 1;

		    } else if (styleRun.offset > offset) {

		    	high = mid - 1;

		    } else {

		    	return mid; // key found

		    }

		}

		return -(low + 1);  // key not found.

	}

	private StyleRange createStyleRange(int start, int end, Style style) {

		StyleRange styleRange= new StyleRange();

		styleRange.start= start;

		styleRange.length= end - start;

		style.applyStyles(styleRange);

		return styleRange;

	}

	/* (non-Javadoc)

	 * @see java.lang.Object#toString()

	 */

	public String toString() {

		return fBuffer.toString();

	}

	private boolean hasRuns() {

		return fStyleRuns != null && !fStyleRuns.isEmpty();

	}

	private void appendStyleRun(Style style, int offset) {

		StyleRun lastRun= getLastRun();

		if (lastRun != null && lastRun.offset == offset) {

			lastRun.style= style;

			return;

		}

		if (lastRun == null && style != null || lastRun != null && isDifferentStyle(style, lastRun.style)) {

			getStyleRuns().add(new StyleRun(offset, style));

		}

	}

	private boolean isDifferentStyle(Style style1, Style style2) {

		if (style1 == null) {

			return style2 != null;

		}

		return !style1.equals(style2);

	}

	private StyleRun getLastRun() {

		if (fStyleRuns == null || fStyleRuns.isEmpty()) {

			return null;

		}

		return fStyleRuns.getRun(fStyleRuns.size() - 1);

	}

	private List getStyleRuns() {

		if (fStyleRuns == null)

			fStyleRuns= new StyleRunList();

		return fStyleRuns;

	}

	private static class StyleRun {

		public int offset;

		public Style style;

		public StyleRun(int offset, Style style) {

			this.offset= offset;

			this.style= style;

		}

		public String toString() {

			return "Offset " + offset + ", style: " + style.toString();  //$NON-NLS-1$//$NON-NLS-2$

		}

	}

	private static class StyleRunList extends ArrayList {

		private static final long serialVersionUID= 123L;

		public StyleRunList() {

			super(3);

		}

		public StyleRun getRun(int index) {

			return (StyleRun) get(index);

		}

		public void removeRange(int fromIndex, int toIndex) {

			super.removeRange(fromIndex, toIndex);

		}	

	}

	private static class DefaultStyle extends Style {

		private final String fForegroundColorName;

		private final String fBackgroundColorName;

		public DefaultStyle(String foregroundColorName, String backgroundColorName) {

			fForegroundColorName= foregroundColorName;	

			fBackgroundColorName= backgroundColorName;

		}

		public void applyStyles(TextStyle textStyle) {

			ColorRegistry colorRegistry= JFaceResources.getColorRegistry();

			if (fForegroundColorName != null) {

				textStyle.foreground= colorRegistry.get(fForegroundColorName);

			}

			if (fBackgroundColorName != null) {

				textStyle.background= colorRegistry.get(fBackgroundColorName);

			}

		}

	}

}

/*******************************************************************************

 * Copyright (c) 2007, 2008 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

 *     Michael Krkoska - initial API and implementation (bug 188333)

 *******************************************************************************/

package org.eclipse.jface.viewers;

import org.eclipse.core.runtime.Assert;

import org.eclipse.jface.window.Window;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.StyleRange;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.graphics.TextLayout;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Event;

/**

 * A {@link StyledCellLabelProvider} supports styled labels by using owner

 * draw.

 * Besides the styles in labels, the label provider preserves native viewer behavior:

 * <ul>

 * <li>similar image and label positioning</li>

 * <li>native drawing of focus and selection</li>

 * </ul>

 * <p>

 * For providing the label's styles, create a subclass and overwrite

 * {@link StyledCellLabelProvider#update(ViewerCell)} to

 * return set all information needed to render a element. Use

 * {@link ViewerCell#setStyleRanges(StyleRange[])} to set style ranges

 * on the label.

 * </p>

 * <p>

 * The current version of the {@link StyledCellLabelProvider} will ignore all font settings on

 * {@link StyleRange}. Different fonts would make labels wider, and the native

 * selection drawing could not be reused.

 * </p>

 * 

 * <p><strong>NOTE:</strong> This API is experimental and may be deleted or

 * changed before 3.4 is released.</p>

 * 

 * @since 3.4

 */

public abstract class StyledCellLabelProvider extends OwnerDrawLabelProvider {

	/**

	 * Style constant for indicating that the styled colors are to be applied

	 * even it the viewer's item is selected. Default is not to apply colors.

	 */

	public static final int COLORS_ON_SELECTION = 1 << 0;

	/**

	 * Style constant for indicating to draw the focus if requested by the owner

	 * draw event. Default is to draw the focus.

	 */

	public static final int NO_FOCUS = 1 << 1;

	/**

	 * Private constant to indicate if owner draw is enabled for the

	 * label provider's column.

	 */

	private static final int OWNER_DRAW_ENABLED = 1 << 4;

	private int style;

	// reused text layout

	private TextLayout cachedTextLayout; 

	private ColumnViewer viewer;

	private ViewerColumn column;

	/**

	 * Creates a new StyledCellLabelProvider. By default, owner draw is enabled, focus is drawn and no 

	 * colors are painted on selected elements.

	 */

	public StyledCellLabelProvider() {

		this(0);

	}

	/**

	 * Creates a new StyledCellLabelProvider. By default, owner draw is enabled.

	 * 

	 * @param style

	 *            the style bits

	 * @see StyledCellLabelProvider#COLORS_ON_SELECTION

	 * @see StyledCellLabelProvider#NO_FOCUS

	 */

	public StyledCellLabelProvider(int style) {

		this.style = style & (COLORS_ON_SELECTION | NO_FOCUS)

							| OWNER_DRAW_ENABLED;

	}

	/**

	 * Returns <code>true</code> is the owner draw rendering is enabled for this label provider.

	 * By default owner draw rendering is enabled. If owner draw rendering is disabled, rending is 

	 * done by the viewer and no styled ranges (see {@link ViewerCell#getStyleRanges()})

	 * are drawn.

	 * 

	 * @return <code>true</code> is the rendering of styles is enabled. 

	 */

	public boolean isOwnerDrawEnabled() {

		return (this.style & OWNER_DRAW_ENABLED) != 0;

	}

	/**

	 * Specifies whether owner draw rendering is enabled for this label

	 * provider. By default owner draw rendering is enabled. If owner draw

	 * rendering is disabled, rendering is done by the viewer and no styled

	 * ranges (see {@link ViewerCell#getStyleRanges()}) are drawn.

	 * It is the caller's responsibility to also call

	 * {@link StructuredViewer#refresh()} or similar methods to update the

	 * underlying widget.

	 * 

	 * @param enabled

	 *            specifies if owner draw rendering is enabled

	 */

	public void setOwnerDrawEnabled(boolean enabled) {

		boolean isEnabled= isOwnerDrawEnabled();

		if (isEnabled != enabled) {

			if (enabled) {

				this.style |= OWNER_DRAW_ENABLED;

			} else {

				this.style &= ~OWNER_DRAW_ENABLED;

			}

			if (this.viewer != null) {

				setOwnerDrawEnabled(this.viewer, this.column, enabled);

			}

		}

	}

	/**

	 * Returns the viewer on which this label provider is installed on or <code>null</code> if the

	 * label provider is not installed.

	 * 

	 * @return the viewer on which this label provider is installed on or <code>null</code> if the

	 * label provider is not installed.

	 */

	protected final ColumnViewer getViewer() {

		return this.viewer;

	}

	/**

	 * Returns the column on which this label provider is installed on or <code>null</code> if the

	 * label provider is not installed.

	 * 

	 * @return the column on which this label provider is installed on or <code>null</code> if the

	 * label provider is not installed.

	 */

	protected final ViewerColumn getColumn() {

		return this.column;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.viewers.OwnerDrawLabelProvider#initialize(org.eclipse.jface.viewers.ColumnViewer, org.eclipse.jface.viewers.ViewerColumn)

	 */

	public void initialize(ColumnViewer viewer, ViewerColumn column) {

		Assert.isTrue(this.viewer == null && this.column == null, "Label provider instance already in use"); //$NON-NLS-1$

		this.viewer= viewer;

		this.column= column;

		super.initialize(viewer, column, isOwnerDrawEnabled());

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.viewers.BaseLabelProvider#dispose()

	 */

	public void dispose() {

		if (this.cachedTextLayout != null) {

			cachedTextLayout.dispose();

			cachedTextLayout = null;

		}

		this.viewer= null;

		this.column= null;

		super.dispose();

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.viewers.OwnerDrawLabelProvider#update(org.eclipse.jface.viewers.ViewerCell)

	 */

	public void update(ViewerCell cell) {

		// clients must override and configure the cell and call super

		super.update(cell); // calls 'repaint' to trigger the paint listener

	}

	private TextLayout getSharedTextLayout(Display display) {

		if (cachedTextLayout == null) {

			cachedTextLayout = new TextLayout(display);

			cachedTextLayout.setOrientation(Window.getDefaultOrientation());

		} else {

			cachedTextLayout.setText(""); // make sure no previous ranges are cleared //$NON-NLS-1$

		}

		return cachedTextLayout;

	}

	private boolean useColors(Event event) {

		return (event.detail & SWT.SELECTED) == 0

				|| (this.style & COLORS_ON_SELECTION) != 0;

	}

	private boolean drawFocus(Event event) {

		return (event.detail & SWT.FOCUSED) != 0

				&& (this.style & NO_FOCUS) == 0;

	}

	/**

	 * Returns a {@link TextLayout} instance for the given cell

	 * configured with the style ranges. The text layout instance is managed by

	 * the label provider. Caller of the method must not dispose the text

	 * layout.

	 * 

	 * @param diplay

	 *            the current display

	 * @param applyColors

	 *            if set, create colors in the result

	 * @param cell

	 *            the viewer cell

	 * @return a TextLayout instance

	 */

	private TextLayout getTextLayoutForInfo(Display display, ViewerCell cell, boolean applyColors) {

		TextLayout layout = getSharedTextLayout(display);

		layout.setText(cell.getText());

		layout.setFont(cell.getFont()); // set also if null to clear previous usages

		StyleRange[] styleRanges = cell.getStyleRanges();

		if (styleRanges != null) { // user didn't fill styled ranges

			for (int i = 0; i < styleRanges.length; i++) {

				StyleRange curr = prepareStyleRange(styleRanges[i], applyColors);

				layout.setStyle(curr, curr.start, curr.start + curr.length - 1);

			}

		}

		return layout;

	}

	/**

	 * Prepares the given style range before it is applied to the label. This method makes sure that

	 * no colors are drawn when the element is selected.

	 * The current version of the {@link StyledCellLabelProvider} will also ignore all font settings on the

	 * style range. Clients can override. 

	 *  

	 * @param styleRange

	 *               the style range to prepare. the style range element must not be modified

	 * @param applyColors

	 *               specifies if colors should be applied.

	 * @return

	 *               returns the style range to use on the label

	 */

	protected StyleRange prepareStyleRange(StyleRange styleRange, boolean applyColors) {

		// if no colors apply or font is set, create a clone and clear the

		// colors and font

		if (styleRange.font != null || !applyColors

				&& (styleRange.foreground != null || styleRange.background != null)) {

			styleRange = (StyleRange) styleRange.clone();

			styleRange.font = null; // ignore font settings until bug 168807 is resolved

			if (!applyColors) {

				styleRange.foreground = null;

				styleRange.background = null;

			}

		}

		return styleRange;

	}

	private ViewerCell getViewerCell(Event event, Object element) {

		ViewerRow row= viewer.getViewerRowFromItem(event.item);

		return new ViewerCell(row, event.index, element);

	}

	/**

	 * Handle the erase event. The default implementation does nothing to ensure

	 * keep native selection highlighting working.

	 * 

	 * @param event

	 *            the erase event

	 * @param element

	 *            the model object

	 * @see SWT#EraseItem

	 */

	protected void erase(Event event, Object element) {

		// use native erase

		if (isOwnerDrawEnabled()) {

			// info has been set by 'update': announce that we paint ourselves

			event.detail &= ~SWT.FOREGROUND;

		}

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.viewers.OwnerDrawLabelProvider#measure(org.eclipse.swt.widgets.Event,

	 *      java.lang.Object)

	 */

	protected void measure(Event event, Object element) {

		// use native measuring

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.viewers.OwnerDrawLabelProvider#paint(org.eclipse.swt.widgets.Event,

	 *      java.lang.Object)

	 */

	protected void paint(Event event, Object element) {

		if (!isOwnerDrawEnabled())

			return;

		ViewerCell cell= getViewerCell(event, element);

		boolean applyColors = useColors(event);

		GC gc = event.gc;

		// remember colors to restore the GC later

		Color oldForeground = gc.getForeground();

		Color oldBackground = gc.getBackground();

		if (applyColors) {

			Color foreground= cell.getForeground();

			if (foreground != null) {

				gc.setForeground(foreground);

			}

			Color background= cell.getBackground();

			if (background != null) {

				gc.setBackground(background);

			}

		}

		Image image = cell.getImage();

		if (image != null) {

			Rectangle imageBounds = cell.getImageBounds();

			Rectangle bounds = image.getBounds();

			// center the image in the given space

			int x = imageBounds.x

					+ Math.max(0, (imageBounds.width - bounds.width) / 2);

			int y = imageBounds.y

					+ Math.max(0, (imageBounds.height - bounds.height) / 2);

			gc.drawImage(image, x, y);

		}

		TextLayout textLayout = getTextLayoutForInfo(event.display, cell, applyColors);

		Rectangle textBounds = cell.getTextBounds();

		Rectangle layoutBounds = textLayout.getBounds();

		int x = textBounds.x;

		int y = textBounds.y

				+ Math.max(0, (textBounds.height - layoutBounds.height) / 2);

		textLayout.draw(gc, x, y);

		if (drawFocus(event)) {

			Rectangle focusBounds = cell.getViewerRow().getBounds();

			gc.drawFocus(focusBounds.x, focusBounds.y, focusBounds.width,

					focusBounds.height);

		}

		if (applyColors) {

			gc.setForeground(oldForeground);

			gc.setBackground(oldBackground);

		}

	}

}

import java.text.DateFormat;

import org.eclipse.swt.graphics.RGB;

		JFaceResources.getColorRegistry().put(JFacePreferences.COUNTER_COLOR, new RGB(0,127,174));

		public StyledString getStyledText(Object element) {

			String text= getText(element);

			StyledString styledString= new StyledString(text);

			if (element instanceof File) {

				File file= (File) element;

				if (file.isFile()) {

					String decoration= MessageFormat.format(" ({0} bytes)", new Object[] { new Long(file.length()) }); //$NON-NLS-1$

					styledString.append(decoration, StyledString.COUNTER_STYLE);

				}

			}	

			return styledString;

		}

		public StyledString getStyledText(Object element) {

			String text= getText(element);

			StyledString styledString= new StyledString(text);

			if (element instanceof File) {

				File file= (File) element;

				String decoration = DateFormat.getTimeInstance(3).format(new Date(file.lastModified()));

				styledString.append(' ');

				styledString.append(decoration, StyledString.COUNTER_STYLE);

			}

			return styledString;

		}

import org.eclipse.swt.graphics.RGB;

		JFaceResources.getColorRegistry().put(JFacePreferences.COUNTER_COLOR, new RGB(0,127,174));

		public void removeListener(ILabelProviderListener listener) {

			super.removeListener(listener);

			fWrappedLabelProvider.removeListener(listener);

		}