/*******************************************************************************
* Copyright (c) 2003, 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.presentations;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.FontMetrics;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Layout;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.internal.WorkbenchMessages;
import org.eclipse.ui.internal.misc.StringMatcher;
import org.eclipse.ui.internal.presentations.defaultpresentation.DefaultTabItem;
/**
* @since 3.0
*/
public abstract class AbstractTableInformationControl {
/**
* The NamePatternFilter selects the elements which match the given string
* patterns.
*/
protected class NamePatternFilter extends ViewerFilter {
public NamePatternFilter() {
//no-op
}
/*
* (non-Javadoc) Method declared on ViewerFilter.
*/
public boolean select(Viewer viewer, Object parentElement,
Object element) {
StringMatcher matcher = getMatcher();
if (matcher == null || !(viewer instanceof TableViewer)) {
return true;
}
TableViewer tableViewer = (TableViewer) viewer;
String matchName = ((ILabelProvider) tableViewer.getLabelProvider())
.getText(element);
if(matchName == null) {
return false;
}
// A dirty editor's label will start with dirty prefix, this prefix
// should not be taken in consideration when matching with a pattern
String prefix = DefaultTabItem.DIRTY_PREFIX;
if (matchName.startsWith(prefix)) {
matchName = matchName.substring(prefix.length());
}
return matchName != null && matcher.match(matchName);
}
}
private static class BorderFillLayout extends Layout {
/** The border widths. */
final int fBorderSize;
/**
* Creates a fill layout with a border.
*/
public BorderFillLayout(int borderSize) {
if (borderSize < 0) {
throw new IllegalArgumentException();
}
fBorderSize = borderSize;
}
/**
* Returns the border size.
*/
public int getBorderSize() {
return fBorderSize;
}
/*
* @see org.eclipse.swt.widgets.Layout#computeSize(org.eclipse.swt.widgets.Composite,
* int, int, boolean)
*/
protected Point computeSize(Composite composite, int wHint, int hHint,
boolean flushCache) {
Control[] children = composite.getChildren();
Point minSize = new Point(0, 0);
if (children != null) {
for (int i = 0; i < children.length; i++) {
Point size = children[i].computeSize(wHint, hHint,
flushCache);
minSize.x = Math.max(minSize.x, size.x);
minSize.y = Math.max(minSize.y, size.y);
}
}
minSize.x += fBorderSize * 2 + RIGHT_MARGIN;
minSize.y += fBorderSize * 2;
return minSize;
}
/*
* @see org.eclipse.swt.widgets.Layout#layout(org.eclipse.swt.widgets.Composite,
* boolean)
*/
protected void layout(Composite composite, boolean flushCache) {
Control[] children = composite.getChildren();
Point minSize = new Point(composite.getClientArea().width,
composite.getClientArea().height);
if (children != null) {
for (int i = 0; i < children.length; i++) {
Control child = children[i];
child.setSize(minSize.x - fBorderSize * 2, minSize.y
- fBorderSize * 2);
child.setLocation(fBorderSize, fBorderSize);
}
}
}
}
/** Border thickness in pixels. */
private static final int BORDER = 1;
/** Right margin in pixels. */
private static final int RIGHT_MARGIN = 3;
/** The control's shell */
private Shell fShell;
/** The composite */
protected Composite fComposite;
/** The control's text widget */
private Text fFilterText;
/** The control's table widget */
private TableViewer fTableViewer;
/** The control width constraint */
//private int fMaxWidth= -1;
/** The control height constraint */
//private int fMaxHeight= -1;
/** The current string matcher */
private StringMatcher fStringMatcher;
/**
* Creates an information control with the given shell as parent. The given
* styles are applied to the shell and the table widget.
*
* @param parent
* the parent shell
* @param shellStyle
* the additional styles for the shell
* @param controlStyle
* the additional styles for the control
*/
public AbstractTableInformationControl(Shell parent, int shellStyle,
int controlStyle) {
fShell = new Shell(parent, shellStyle);
Display display = fShell.getDisplay();
fShell.setBackground(display.getSystemColor(SWT.COLOR_BLACK));
// Composite for filter text and viewer
fComposite = new Composite(fShell, SWT.RESIZE);
GridLayout layout = new GridLayout(1, false);
fComposite.setLayout(layout);
// fComposite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
createFilterText(fComposite);
fTableViewer = createTableViewer(fComposite, controlStyle);
final Table table = fTableViewer.getTable();
table.addKeyListener(new KeyListener() {
public void keyPressed(KeyEvent e) {
if (e.character == SWT.ESC) {
dispose();
} else if (e.character == SWT.DEL) {
removeSelectedItems();
e.character = SWT.NONE;
e.doit = false;
}
}
public void keyReleased(KeyEvent e) {
// do nothing
}
});
table.addSelectionListener(new SelectionListener() {
public void widgetSelected(SelectionEvent e) {
// do nothing;
}
public void widgetDefaultSelected(SelectionEvent e) {
gotoSelectedElement();
}
});
/*
* Bug in GTK, see SWT bug: 62405 Editor drop down performance slow on
* Linux-GTK on mouse move.
* Rather then removing the support altogether this feature has been
* worked around for GTK only as we expect that newer versions of GTK
* will no longer exhibit this quality and we will be able to have the
* desired support running on all platforms. See
* comment https://bugs.eclipse.org/bugs/show_bug.cgi?id=62405#c22
* TODO: remove this code once bug 62405 is fixed for the mainstream GTK
* version
*/
final int ignoreEventCount = Platform.getWS().equals(Platform.WS_GTK) ? 4 : 1;
table.addMouseMoveListener(new MouseMoveListener() {
TableItem fLastItem = null;
int lastY = 0;
int itemHeightdiv4 = table.getItemHeight() / 4;
int tableHeight = table.getBounds().height;
Point tableLoc = table.toDisplay(0,0);
int divCount = 0;
public void mouseMove(MouseEvent e) {
if (divCount == ignoreEventCount) {
divCount = 0;
}
if (table.equals(e.getSource()) & ++divCount == ignoreEventCount) {
Object o = table.getItem(new Point(e.x, e.y));
if (o instanceof TableItem && lastY != e.y) {
lastY = e.y;
if (!o.equals(fLastItem)) {
fLastItem = (TableItem) o;
table.setSelection(new TableItem[] { fLastItem });
} else if (e.y < itemHeightdiv4) {
// Scroll up
Item item = fTableViewer.scrollUp(e.x + tableLoc.x, e.y + tableLoc.y);
if (item instanceof TableItem) {
fLastItem = (TableItem) item;
table.setSelection(new TableItem[] { fLastItem });
}
} else if (e.y > tableHeight - itemHeightdiv4) {
// Scroll down
Item item = fTableViewer.scrollDown(e.x + tableLoc.x, e.y + tableLoc.y);
if (item instanceof TableItem) {
fLastItem = (TableItem) item;
table.setSelection(new TableItem[] { fLastItem });
}
}
}
}
}
});
table.addMouseListener(new MouseAdapter() {
public void mouseUp(MouseEvent e) {
if (table.getSelectionCount() < 1) {
return;
}
if (e.button == 1) {
if (table.equals(e.getSource())) {
Object o = table.getItem(new Point(e.x, e.y));
TableItem selection = table.getSelection()[0];
if (selection.equals(o)) {
gotoSelectedElement();
}
}
}
if (e.button == 3) {
TableItem tItem = fTableViewer.getTable().getItem(
new Point(e.x, e.y));
if (tItem != null) {
Menu menu = new Menu(fTableViewer.getTable());
MenuItem mItem = new MenuItem(menu, SWT.NONE);
mItem.setText(WorkbenchMessages.PartPane_close);
mItem.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(
SelectionEvent selectionEvent) {
removeSelectedItems();
}
});
menu.setVisible(true);
}
}
}
});
int border = ((shellStyle & SWT.NO_TRIM) == 0) ? 0 : BORDER;
fShell.setLayout(new BorderFillLayout(border));
setInfoSystemColor();
installFilter();
}
/**
* Removes the selected items from the list and closes their corresponding tabs
* Selects the next item in the list or disposes it if its presentation is disposed
*/
protected void removeSelectedItems() {
int selInd = fTableViewer.getTable().getSelectionIndex();
if (deleteSelectedElements()) {
return;
}
fTableViewer.refresh();
if (selInd >= fTableViewer.getTable().getItemCount()) {
selInd = fTableViewer.getTable().getItemCount() - 1;
}
if (selInd >= 0) {
fTableViewer.getTable().setSelection(selInd);
}
}
protected abstract TableViewer createTableViewer(Composite parent, int style);
public TableViewer getTableViewer() {
return fTableViewer;
}
protected Text createFilterText(Composite parent) {
fFilterText = new Text(parent, SWT.NONE);
GridData data = new GridData();
GC gc = new GC(parent);
gc.setFont(parent.getFont());
FontMetrics fontMetrics = gc.getFontMetrics();
gc.dispose();
data.heightHint = org.eclipse.jface.dialogs.Dialog
.convertHeightInCharsToPixels(fontMetrics, 1);
data.horizontalAlignment = GridData.FILL;
data.verticalAlignment = GridData.BEGINNING;
fFilterText.setLayoutData(data);
fFilterText.addKeyListener(new KeyListener() {
public void keyPressed(KeyEvent e) {
if (e.keyCode == 0x0D) {
gotoSelectedElement();
}
if (e.keyCode == SWT.ARROW_DOWN) {
fTableViewer.getTable().setFocus();
fTableViewer.getTable().setSelection(0);
}
if (e.keyCode == SWT.ARROW_UP) {
fTableViewer.getTable().setFocus();
fTableViewer.getTable().setSelection(
fTableViewer.getTable().getItemCount() - 1);
}
if (e.character == 0x1B) {
dispose();
}
}
public void keyReleased(KeyEvent e) {
// do nothing
}
});
// Horizontal separator line
Label separator = new Label(parent, SWT.SEPARATOR | SWT.HORIZONTAL
| SWT.LINE_DOT);
separator.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
return fFilterText;
}
private void setInfoSystemColor() {
Display display = fShell.getDisplay();
setForegroundColor(display.getSystemColor(SWT.COLOR_INFO_FOREGROUND));
setBackgroundColor(display.getSystemColor(SWT.COLOR_INFO_BACKGROUND));
}
private void installFilter() {
fFilterText.setText(""); //$NON-NLS-1$
fFilterText.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent e) {
String text = ((Text) e.widget).getText();
int length = text.length();
if (length > 0 && text.charAt(length - 1) != '*') {
text = text + '*';
}
setMatcherString(text);
}
});
}
/**
* The string matcher has been modified. The default implementation
* refreshes the view and selects the first macthed element
*/
protected void stringMatcherUpdated() {
// refresh viewer to refilter
fTableViewer.getControl().setRedraw(false);
fTableViewer.refresh();
selectFirstMatch();
fTableViewer.getControl().setRedraw(true);
}
/**
* Sets the patterns to filter out for the receiver.
* <p>
* The following characters have special meaning: ? => any character * =>
* any string
* </p>
*/
protected void setMatcherString(String pattern) {
if (pattern.length() == 0) {
fStringMatcher = null;
} else {
boolean ignoreCase = pattern.toLowerCase().equals(pattern);
fStringMatcher = new StringMatcher(pattern, ignoreCase, false);
}
stringMatcherUpdated();
}
protected StringMatcher getMatcher() {
return fStringMatcher;
}
/**
* Implementers can modify
*/
protected Object getSelectedElement() {
return ((IStructuredSelection) fTableViewer.getSelection())
.getFirstElement();
}
/**
* Implementers can modify
*/
protected IStructuredSelection getSelectedElements() {
return (IStructuredSelection) fTableViewer.getSelection();
}
protected abstract void gotoSelectedElement();
/**
* Delete all selected elements.
*
* @return <code>true</code> if there are no elements left after deletion.
*/
protected abstract boolean deleteSelectedElements();
/**
* Selects the first element in the table which matches the current filter
* pattern.
*/
protected void selectFirstMatch() {
Table table = fTableViewer.getTable();
Object element = findElement(table.getItems());
if (element != null) {
fTableViewer.setSelection(new StructuredSelection(element), true);
} else {
fTableViewer.setSelection(StructuredSelection.EMPTY);
}
}
private Object findElement(TableItem[] items) {
ILabelProvider labelProvider = (ILabelProvider) fTableViewer
.getLabelProvider();
for (int i = 0; i < items.length; i++) {
Object element = items[i].getData();
if (fStringMatcher == null) {
return element;
}
if (element != null) {
String label = labelProvider.getText(element);
if(label == null) {
return null;
}
// remove the dirty prefix from the editor's label
String prefix = DefaultTabItem.DIRTY_PREFIX;
if (label.startsWith(prefix)) {
label = label.substring(prefix.length());
}
if (fStringMatcher.match(label)) {
return element;
}
}
}
return null;
}
public abstract void setInput(Object information);
protected void inputChanged(Object newInput, Object newSelection) {
fFilterText.setText(""); //$NON-NLS-1$
fTableViewer.setInput(newInput);
// Resize the table's height accordingly to the new input
Table viewerTable = fTableViewer.getTable();
Point tableSize = viewerTable.computeSize(SWT.DEFAULT, SWT.DEFAULT);
int tableMaxHeight = fComposite.getDisplay().getBounds().height / 2;
// removes padding if necessary
int tableHeight = (tableSize.y <= tableMaxHeight) ? tableSize.y
- viewerTable.getItemHeight() - viewerTable.getItemHeight() / 2
: tableMaxHeight;
((GridData) viewerTable.getLayoutData()).heightHint = tableHeight;
Point fCompSize = fComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT);
fComposite.setSize(fCompSize);
fComposite.getShell().setSize(fCompSize);
}
public void setVisible(boolean visible) {
fShell.setVisible(visible);
}
public void dispose() {
if (fShell != null) {
if (!fShell.isDisposed()) {
fShell.dispose();
}
fShell = null;
fTableViewer = null;
fComposite = null;
fFilterText = null;
}
}
public boolean hasContents() {
return fTableViewer != null && fTableViewer.getInput() != null;
}
public void setSizeConstraints(int maxWidth, int maxHeight) {
//fMaxWidth= maxWidth;
//fMaxHeight= maxHeight;
}
public Point computeSizeHint() {
return fShell.computeSize(SWT.DEFAULT, SWT.DEFAULT);
}
public void setLocation(Point location) {
Rectangle trim = fShell.computeTrim(0, 0, 0, 0);
Point textLocation = fComposite.getLocation();
location.x += trim.x - textLocation.x;
location.y += trim.y - textLocation.y;
fShell.setLocation(location);
}
public void setSize(int width, int height) {
fShell.setSize(width, height);
}
public void addDisposeListener(DisposeListener listener) {
fShell.addDisposeListener(listener);
}
public void removeDisposeListener(DisposeListener listener) {
fShell.removeDisposeListener(listener);
}
public void setForegroundColor(Color foreground) {
fTableViewer.getTable().setForeground(foreground);
fFilterText.setForeground(foreground);
fComposite.setForeground(foreground);
}
public void setBackgroundColor(Color background) {
fTableViewer.getTable().setBackground(background);
fFilterText.setBackground(background);
fComposite.setBackground(background);
}
public boolean isFocusControl() {
return fTableViewer.getControl().isFocusControl()
|| fFilterText.isFocusControl();
}
public void setFocus() {
fShell.forceFocus();
fFilterText.setFocus();
}
public void addFocusListener(FocusListener listener) {
fShell.addFocusListener(listener);
}
public void removeFocusListener(FocusListener listener) {
fShell.removeFocusListener(listener);
}
}