+ */
+public class WrappedStyledCellLabelProvider extends StyledCellLabelProvider {
+
+ private ILabelProvider labelProvider;
+ private IFontProvider fontProvider = null;
+ private IColorProvider colorProvider = null;
+ private ITableLabelProvider tableLabelProvider = null;
+ private ITableFontProvider tableFontProvider = null;
+ private ITableColorProvider tableColorProvider = null;
+ private int columnIndex;
+
+ /**
+ * Creates a WrappedStyledCellLabelProvider for usage with a ViewerColumn.
+ *
+ * @param viewer the viewer for this CellLabelProvider
+ * @param support the StyledLabelSupport for providing the item's style
+ * @param labelProvider the label provider implementing ILabelProvider and optionally IFontProvider or IColorProvider
+ */
+ public WrappedStyledCellLabelProvider( ColumnViewer viewer, StyledLabelSupport support, IBaseLabelProvider labelProvider ) {
+ this(viewer, support, labelProvider, 0);
+ }
+
+ /**
+ * Creates a WrappedStyledCellLabelProvider for usage with a ViewerColumn.
+ *
+ * @param viewer the viewer for this CellLabelProvider
+ * @param support the StyledLabelSupport for providing the item's style
+ * @param labelProvider the label provider implementing ILabelProvider and optionally IFontProvider or IColorProvider
+ * @param columnIndex the column index to pass to a wrapped ITable*Provider
+ */
+ public WrappedStyledCellLabelProvider( ColumnViewer viewer, StyledLabelSupport support, IBaseLabelProvider labelProvider, int columnIndex ) {
+ super(viewer, support);
+ this.columnIndex = columnIndex;
+ setLabelProvider(labelProvider);
+ }
+
+ public Color getBackground( Object element ) {
+ if ( tableColorProvider != null ) {
+ return tableColorProvider.getBackground(element, columnIndex);
+ }
+ if ( colorProvider != null && columnIndex == 0 ) {
+ return colorProvider.getBackground(element);
+ }
+ return null;
+ }
+
+ public Font getFont( Object element ) {
+ if ( tableFontProvider != null ) {
+ return tableFontProvider.getFont(element, columnIndex);
+ }
+ if ( fontProvider != null && columnIndex == 0 ) {
+ return fontProvider.getFont(element);
+ }
+ return null;
+ }
+
+ public Color getForeground( Object element ) {
+ if ( tableColorProvider != null ) {
+ return tableColorProvider.getForeground(element, columnIndex);
+ }
+ if ( colorProvider != null && columnIndex == 0 ) {
+ return colorProvider.getForeground(element);
+ }
+ return null;
+ }
+
+ public Image getImage( Object element ) {
+ if ( tableLabelProvider != null ) {
+ return tableLabelProvider.getColumnImage(element, columnIndex);
+ }
+ if ( columnIndex == 0 ) {
+ return labelProvider.getImage(element);
+ }
+ return null;
+ }
+
+ public String getText( Object element ) {
+ if ( tableLabelProvider != null ) {
+ return tableLabelProvider.getColumnText(element, columnIndex);
+ }
+ if ( columnIndex == 0 ) {
+ return labelProvider.getText(element);
+ }
+ return ""; //$NON-NLS-1$
+ }
+
+ private void setLabelProvider( IBaseLabelProvider labelProvider ) {
+ Assert.isTrue(labelProvider instanceof ITableLabelProvider || labelProvider instanceof ILabelProvider);
+ if ( labelProvider instanceof ILabelProvider ) {
+ this.labelProvider = (ILabelProvider)labelProvider;
+ }
+ if ( labelProvider instanceof IFontProvider ) {
+ fontProvider = (IFontProvider)labelProvider;
+ }
+ if ( labelProvider instanceof IColorProvider ) {
+ colorProvider = (IColorProvider)labelProvider;
+ }
+ if ( labelProvider instanceof ITableLabelProvider ) {
+ tableLabelProvider = (ITableLabelProvider)labelProvider;
+ }
+ if ( labelProvider instanceof ITableFontProvider ) {
+ tableFontProvider = (ITableFontProvider)labelProvider;
+ }
+ if ( labelProvider instanceof ITableColorProvider ) {
+ tableColorProvider = (ITableColorProvider)labelProvider;
+ }
+ }
+
+}
Index: src/org/eclipse/jface/viewers/StyledMultiLineLabelSupport.java
===================================================================
RCS file: src/org/eclipse/jface/viewers/StyledMultiLineLabelSupport.java
diff -N src/org/eclipse/jface/viewers/StyledMultiLineLabelSupport.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ src/org/eclipse/jface/viewers/StyledMultiLineLabelSupport.java 1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,307 @@
+/*******************************************************************************
+ * Copyright (c) 2007 Michael Krkoska 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:
+ * Michael Krkoska - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.jface.viewers;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.Font;
+import org.eclipse.swt.graphics.GlyphMetrics;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.graphics.TextLayout;
+import org.eclipse.swt.graphics.TextStyle;
+import org.eclipse.swt.widgets.Event;
+import org.eclipse.swt.widgets.Listener;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.swt.widgets.TableColumn;
+import org.eclipse.swt.widgets.TableItem;
+import org.eclipse.swt.widgets.Tree;
+import org.eclipse.swt.widgets.TreeColumn;
+import org.eclipse.swt.widgets.TreeItem;
+
+
+/**
+ * A StyledLabelSupport which supports multiple lines per label.
+ *
+ *
+ * To set up a StyledMultiLineLabelSupport for your viewer's control, you must call
+ * {@link StyledMultiLineLabelSupport#setUpMultiLineLabelSupport(ColumnViewer)}.
+ *
+ * @since 3.4
+ * @author Michael Krkoska
+ */
+public abstract class StyledMultiLineLabelSupport extends StyledLabelSupport {
+
+ /**
+ * Set up the owner draw callbacks for the viewer and enable multi line support for StyledCellLabelProviders.
+ * @param viewer
+ * the viewer the owner draw is set up
+ */
+ public static void setUpMultiLineLabelSupport( final ColumnViewer viewer ) {
+ OwnerDrawLabelProvider.setUpOwnerDraw(viewer);
+
+ Listener l = new Listener() {
+
+ public void handleEvent( Event event ) {
+ ViewerColumn column;
+ int i = 0;
+ while ( (column = viewer.getViewerColumn(i++)) != null ) {
+ CellLabelProvider provider = column.getLabelProvider();
+
+ if ( provider instanceof StyledCellLabelProvider ) {
+ StyledLabelSupport styledLabelSupport = ((StyledCellLabelProvider)provider).getStyledLabelSupport();
+ if ( styledLabelSupport instanceof StyledMultiLineLabelSupport ) {
+ ((StyledMultiLineLabelSupport)styledLabelSupport).columnsResized(event);
+ }
+ }
+ }
+ }
+
+ };
+ if ( viewer.getControl() instanceof Table ) {
+ Table table = (Table)viewer.getControl();
+ TableColumn[] cols = table.getColumns();
+ for ( int i = 0; i < cols.length; i++ ) {
+ cols[i].addListener(SWT.Resize, l);
+ }
+ }
+ else if ( viewer.getControl() instanceof Tree ) {
+ Tree tree = (Tree)viewer.getControl();
+ TreeColumn[] cols = tree.getColumns();
+ for ( int i = 0; i < cols.length; i++ ) {
+ cols[i].addListener(SWT.Resize, l);
+ }
+ }
+ }
+
+ private boolean wrapLines = false;
+ private int measureHeightIndex = -1;
+ private int maxHeight = 0;
+ private int[] knownColumnWidths;
+
+ /**
+ * Creates a new StyledMultiLineLabelSupport.
+ *
+ * @param style
+ * the style bits
+ * @see StyledLabelSupport#CENTER_ITEMS_VERTICALLY
+ * @see StyledLabelSupport#CENTER_TEXT_VERTICALLY
+ */
+ /* @see SWT#WRAP */
+ public StyledMultiLineLabelSupport( int style ) {
+ super(style);
+ if ( (SWT.WRAP & style) != 0 ) {
+ // TODO Wrapping is deactivated as long as either Bug 130024 or Bug 148039 are still existing
+ // wrapLines = true;
+ }
+ }
+
+ protected TextLayout createTextLayout( Event event, String label, Image image, Font defaultFont, Color defaultBackground, Object element ) {
+
+ TextLayout layout = super.createTextLayout(event, label, image, defaultFont, defaultBackground, element);
+
+ if ( centerTextVertically && image != null ) {
+ int imageOffset = Math.max(0, label.indexOf(IMAGE_PLACEHOLDER));
+ GlyphMetrics imageMetrics = layout.getStyle(imageOffset).metrics;
+
+ if ( imageMetrics != null ) {
+ int lineCount = layout.getLineCount();
+ if ( lineCount > 1 ) {
+ // do a different (unfortunately inferior) centering for multiline text
+ // than in the single line case
+ centerMultilineVertically(layout, defaultFont, imageMetrics, imageOffset);
+ }
+ }
+ }
+
+ if ( wrapLines ) {
+ layout.setWidth(Math.max(getItemWidth(event), 16));
+ }
+
+ return layout;
+ }
+
+ protected void measure( Event event, Object element, ViewerLabel viewerLabel ) {
+ super.measure(event, element, viewerLabel);
+
+ if ( measureHeightIndex == event.index ) {
+ maxHeight = Math.max(event.getBounds().height, maxHeight);
+ }
+ }
+
+ private void centerMultilineVertically( TextLayout layout, Font defaultFont, GlyphMetrics imageMetrics, int imageOffset ) {
+
+ Font systemFont = layout.getDevice().getSystemFont();
+
+ int maxFontHeight = 0;
+ int lineIndex = layout.getLineIndex(imageOffset);
+ int[] lineOffsets = layout.getLineOffsets();
+ int lineStart = lineOffsets[lineIndex];
+ int lineEnd = lineOffsets[lineIndex + 1] - 1;
+ int oldEnd = -1;
+ int[] ranges = layout.getRanges();
+ TextStyle[] styles = layout.getStyles();
+ List lineStyles = new ArrayList();
+
+ for ( int i = 0, length = ranges.length; i < length; i += 2 ) {
+ int start = ranges[i];
+ int end = ranges[i + 1];
+
+ if ( start > oldEnd + 1 ) {
+ TextStyle style = new TextStyle(null, null, null);
+ layout.setStyle(style, Math.max(oldEnd + 1, lineStart), Math.min(start - 1, lineEnd));
+ lineStyles.add(style);
+ Font font = getFirstNotNullFont(style.font, defaultFont, systemFont);
+ maxFontHeight = Math.max(maxFontHeight, getFontHeight(font));
+ }
+
+ if ( start > lineEnd || end < lineStart ) {
+ continue;
+ }
+ if ( start == imageOffset && end == imageOffset ) {
+ oldEnd = end;
+ continue;
+ }
+
+ TextStyle style = styles[i >> 1];
+ if ( end > lineEnd ) {
+ TextStyle clonedStyle = cloneStyle(style);
+ layout.setStyle(clonedStyle, Math.max(start, lineStart), Math.min(end, lineEnd));
+ lineStyles.add(clonedStyle);
+ Font font = getFirstNotNullFont(style.font, defaultFont, systemFont);
+ maxFontHeight = Math.max(maxFontHeight, getFontHeight(font));
+ }
+ else {
+ lineStyles.add(style);
+ }
+
+ oldEnd = end;
+ }
+ if ( layout.getText().length() > oldEnd + 1 ) {
+ TextStyle style = new TextStyle(null, null, null);
+ layout.setStyle(style, Math.max(oldEnd + 1, lineStart), Math.min(layout.getText().length() - 1, lineEnd));
+ lineStyles.add(style);
+ Font font = getFirstNotNullFont(style.font, defaultFont, systemFont);
+ maxFontHeight = Math.max(maxFontHeight, getFontHeight(font));
+ }
+
+ if ( imageMetrics.ascent > maxFontHeight ) {
+ int height = imageMetrics.ascent;
+ int space = (height - maxFontHeight);
+ int rise = Math.round(space / 2f);
+ for ( Iterator iterator = lineStyles.iterator(); iterator.hasNext(); ) {
+ TextStyle style = (TextStyle)iterator.next();
+ style.rise = rise;
+ }
+ }
+ }
+
+ private TextStyle cloneStyle( TextStyle style ) {
+ TextStyle clone = new TextStyle(style.font, style.foreground, style.background);
+ clone.rise = style.rise;
+ clone.strikeout = style.strikeout;
+ if ( style.metrics != null ) {
+ clone.metrics = new GlyphMetrics(style.metrics.ascent, style.metrics.descent, style.metrics.width);
+ }
+ return clone;
+ }
+
+ private void columnsResized( Event event ) {
+ if ( !wrapLines ) {
+ return;
+ }
+ initKnownWidths(event);
+ if ( event.widget instanceof TableColumn ) {
+ TableColumn tc = (TableColumn)event.widget;
+ int newWidth = tc.getWidth();
+ if ( newWidth == knownColumnWidths[event.index] ) {
+ return;
+ }
+ knownColumnWidths[event.index] = newWidth;
+ int index = tc.getParent().indexOf(tc);
+ measureHeightIndex = index;
+ maxHeight = 0;
+ tc.getParent().redraw();
+ tc.getParent().update(); // trigger measure events for all visible items -> calculates maxHeight
+ if ( maxHeight >= tc.getParent().getItemHeight() ) {
+ return;
+ }
+ // TODO This is deactivated as long as either Bug 130024 or Bug 148039 are still existing
+ // tc.getParent().setItemHeight(maxHeight);
+ measureHeightIndex = -1;
+ maxHeight = 0;
+ tc.getParent().redraw();
+ tc.getParent().update();
+ }
+ else if ( event.widget instanceof TreeColumn ) {
+ TreeColumn tc = (TreeColumn)event.widget;
+ int newWidth = tc.getWidth();
+ if ( newWidth == knownColumnWidths[event.index] ) {
+ return;
+ }
+ knownColumnWidths[event.index] = newWidth;
+ int index = tc.getParent().indexOf(tc);
+ measureHeightIndex = index;
+ maxHeight = 0;
+ tc.getParent().redraw();
+ tc.getParent().update(); // trigger measure events for all visible items -> calculates maxHeight
+ if ( maxHeight >= tc.getParent().getItemHeight() ) {
+ return;
+ }
+ // TODO This is deactivated as long as either Bug 130024 or Bug 148039 are still existing
+ // tc.getParent().setItemHeight(maxHeight);
+ measureHeightIndex = -1;
+ maxHeight = 0;
+ tc.getParent().redraw();
+ tc.getParent().update();
+ }
+ }
+
+ private Font getFirstNotNullFont( Font f1, Font f2, Font f3 ) {
+ if ( f1 != null ) {
+ return f1;
+ }
+ if ( f2 != null ) {
+ return f2;
+ }
+ return f3;
+ }
+
+ private int getItemWidth( Event event ) {
+ if ( !wrapLines ) {
+ return -1;
+ }
+ if ( event.item instanceof TableItem ) {
+ return ((TableItem)event.item).getBounds(event.index).width;
+ }
+ if ( event.item instanceof TreeItem ) {
+ return ((TreeItem)event.item).getBounds(event.index).width;
+ }
+ return -1;
+ }
+
+ private void initKnownWidths( Event event ) {
+ if ( knownColumnWidths == null ) {
+ if ( event.widget instanceof TableColumn ) {
+ TableColumn tc = (TableColumn)event.widget;
+ knownColumnWidths = new int[tc.getParent().getColumnCount()];
+ }
+ else if ( event.widget instanceof TreeColumn ) {
+ TreeColumn tc = (TreeColumn)event.widget;
+ knownColumnWidths = new int[tc.getParent().getColumnCount()];
+ }
+ }
+ }
+}