| /******************************************************************************* |
| * 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.internal; |
| |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.layout.GridDataFactory; |
| import org.eclipse.jface.layout.GridLayoutFactory; |
| import org.eclipse.jface.resource.JFaceResources; |
| import org.eclipse.jface.window.IShellProvider; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Item; |
| import org.eclipse.swt.widgets.Label; |
| 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.Text; |
| import org.eclipse.swt.widgets.Tree; |
| import org.eclipse.swt.widgets.TreeColumn; |
| |
| /** |
| * NON-API - This class is internal and will be moved to another package in 3.5. |
| * |
| */ |
| public class ConfigureColumnsDialog extends Dialog { |
| |
| private Control targetControl; |
| private ColumnObject[] columnObjects; |
| private Table table; |
| private Button upButton; |
| private Button downButton; |
| private Text text; |
| private boolean moveableColumnsFound; |
| |
| class ColumnObject { |
| Item column; |
| int index; |
| String name; |
| Image image; |
| boolean visible; |
| int width; |
| boolean moveable; |
| boolean resizable; |
| |
| ColumnObject(Item column, int index, String text, Image image, |
| int width, boolean moveable, boolean resizable, boolean visible) { |
| this.column = column; |
| this.index = index; |
| this.name = text; |
| this.image = image; |
| this.width = width; |
| this.moveable = moveable; |
| this.resizable = resizable; |
| this.visible = visible; |
| } |
| } |
| |
| /** |
| * NON-API - This class is internal and will be moved to another package in |
| * 3.5. Creates a new dialog for configuring columns of the given column |
| * viewer. The column viewer must have an underlying {@link Tree} or {@link |
| * Table}, other controls are not supported. |
| * |
| * @param shellProvider |
| * @param table |
| */ |
| public ConfigureColumnsDialog(IShellProvider shellProvider, Table table) { |
| this(shellProvider, (Control) table); |
| } |
| |
| /** |
| * NON-API - This class is internal and will be moved to another package in |
| * 3.5. Creates a new dialog for configuring columns of the given column |
| * viewer. The column viewer must have an underlying {@link Tree} or {@link |
| * Table}, other controls are not supported. |
| * |
| * @param shellProvider |
| * @param tree |
| */ |
| public ConfigureColumnsDialog(IShellProvider shellProvider, Tree tree) { |
| this(shellProvider, (Control) tree); |
| } |
| |
| /** |
| * @param shellProvider |
| * @param control |
| */ |
| private ConfigureColumnsDialog(IShellProvider shellProvider, Control control) { |
| super(shellProvider); |
| this.targetControl = control; |
| this.moveableColumnsFound = createColumnObjects(); |
| } |
| |
| protected boolean isResizable() { |
| return true; |
| } |
| |
| public void create() { |
| super.create(); |
| getShell().setText( |
| JFaceResources.getString("ConfigureColumnsDialog_Title")); //$NON-NLS-1$ |
| } |
| |
| protected void initializeBounds() { |
| super.initializeBounds(); |
| table.setSelection(0); |
| handleSelectionChanged(0); |
| } |
| |
| /** |
| * Returns true if any of the columns is moveable (can be reordered). |
| */ |
| private boolean createColumnObjects() { |
| boolean result = true; |
| Item[] columns = getViewerColumns(); |
| ColumnObject[] cObjects = new ColumnObject[columns.length]; |
| for (int i = 0; i < columns.length; i++) { |
| Item c = columns[i]; |
| boolean moveable = getMoveable(c); |
| result = result && moveable; |
| cObjects[i] = new ColumnObject(c, i, getColumnName(c), |
| getColumnImage(c), getColumnWidth(c), moveable, |
| getResizable(c), true); |
| } |
| int[] columnOrder = getColumnOrder(); |
| columnObjects = new ColumnObject[columns.length]; |
| for (int i = 0; i < columnOrder.length; i++) { |
| columnObjects[i] = cObjects[columnOrder[i]]; |
| } |
| return result; |
| } |
| |
| /** |
| * @param c |
| * @return |
| */ |
| private Image getColumnImage(Item item) { |
| if (item instanceof TableColumn) { |
| return ((TableColumn) item).getImage(); |
| } else if (item instanceof TreeColumn) { |
| return ((TreeColumn) item).getImage(); |
| } |
| return null; |
| } |
| |
| /** |
| * @return |
| */ |
| private int[] getColumnOrder() { |
| if (targetControl instanceof Table) { |
| return ((Table) targetControl).getColumnOrder(); |
| } else if (targetControl instanceof Tree) { |
| return ((Tree) targetControl).getColumnOrder(); |
| } |
| return new int[0]; |
| } |
| |
| /** |
| * @param c |
| * @return |
| */ |
| private boolean getMoveable(Item item) { |
| if (item instanceof TableColumn) { |
| return ((TableColumn) item).getMoveable(); |
| } else if (item instanceof TreeColumn) { |
| return ((TreeColumn) item).getMoveable(); |
| } |
| return false; |
| } |
| |
| /** |
| * @param c |
| * @return |
| */ |
| private boolean getResizable(Item item) { |
| if (item instanceof TableColumn) { |
| return ((TableColumn) item).getResizable(); |
| } else if (item instanceof TreeColumn) { |
| return ((TreeColumn) item).getResizable(); |
| } |
| return false; |
| } |
| |
| protected Control createDialogArea(Composite parent) { |
| Composite composite = (Composite) super.createDialogArea(parent); |
| |
| table = new Table(composite, SWT.BORDER | SWT.SINGLE | SWT.V_SCROLL |
| | SWT.H_SCROLL /* |
| * | SWT.CHECK |
| */); |
| for (int i = 0; i < columnObjects.length; i++) { |
| TableItem tableItem = new TableItem(table, SWT.NONE); |
| tableItem.setText(columnObjects[i].name); |
| tableItem.setImage(columnObjects[i].image); |
| tableItem.setData(columnObjects[i]); |
| } |
| |
| GridDataFactory.defaultsFor(table) |
| .span(1, moveableColumnsFound ? 3 : 1).applyTo(table); |
| |
| if (moveableColumnsFound) { |
| upButton = new Button(composite, SWT.PUSH); |
| upButton.setText(JFaceResources |
| .getString("ConfigureColumnsDialog_up")); //$NON-NLS-1$ |
| upButton.addListener(SWT.Selection, new Listener() { |
| public void handleEvent(Event event) { |
| handleMove(table, true); |
| } |
| }); |
| setButtonLayoutData(upButton); |
| downButton = new Button(composite, SWT.PUSH); |
| downButton.setText(JFaceResources |
| .getString("ConfigureColumnsDialog_down")); //$NON-NLS-1$ |
| downButton.addListener(SWT.Selection, new Listener() { |
| public void handleEvent(Event event) { |
| handleMove(table, false); |
| } |
| }); |
| setButtonLayoutData(downButton); |
| |
| // filler label |
| createLabel(composite, ""); //$NON-NLS-1$ |
| } |
| |
| Composite widthComposite = new Composite(composite, SWT.NONE); |
| createLabel(widthComposite, JFaceResources |
| .getString("ConfigureColumnsDialog_WidthOfSelectedColumn")); //$NON-NLS-1$ |
| |
| text = new Text(widthComposite, SWT.SINGLE | SWT.BORDER); |
| // see #initializeBounds |
| text.setText(Integer.toString(1000)); |
| |
| GridLayoutFactory.fillDefaults().numColumns(2).applyTo(widthComposite); |
| |
| int numColumns = moveableColumnsFound ? 2 : 1; |
| |
| GridDataFactory.defaultsFor(widthComposite).grab(false, false).span( |
| numColumns, 1).applyTo(widthComposite); |
| |
| GridLayoutFactory.swtDefaults().numColumns(numColumns).applyTo( |
| composite); |
| |
| table.addListener(SWT.Selection, new Listener() { |
| public void handleEvent(Event event) { |
| handleSelectionChanged(table.indexOf((TableItem) event.item)); |
| } |
| }); |
| text.addListener(SWT.Modify, new Listener() { |
| public void handleEvent(Event event) { |
| ColumnObject columnObject = columnObjects[table |
| .getSelectionIndex()]; |
| if (!columnObject.resizable) { |
| return; |
| } |
| try { |
| int width = Integer.parseInt(text.getText()); |
| columnObject.width = width; |
| } catch (NumberFormatException ex) { |
| // ignore for now |
| } |
| } |
| }); |
| |
| return composite; |
| } |
| |
| /** |
| * @param table |
| * @param up |
| */ |
| protected void handleMove(Table table, boolean up) { |
| int index = table.getSelectionIndex(); |
| int newIndex = index + (up ? -1 : 1); |
| if (index < 0 || index >= table.getItemCount()) { |
| return; |
| } |
| ColumnObject columnObject = columnObjects[index]; |
| columnObjects[index] = columnObjects[newIndex]; |
| columnObjects[newIndex] = columnObject; |
| table.getItem(index).dispose(); |
| TableItem newItem = new TableItem(table, SWT.NONE, newIndex); |
| newItem.setText(columnObject.name); |
| newItem.setImage(columnObject.image); |
| newItem.setData(columnObject); |
| table.setSelection(newIndex); |
| handleSelectionChanged(newIndex); |
| } |
| |
| private void createLabel(final Composite composite, String string) { |
| Label label = new Label(composite, SWT.NONE); |
| label.setText(string); |
| } |
| |
| /** |
| * @param item |
| * @return |
| */ |
| private String getColumnName(Item item) { |
| String result = ""; //$NON-NLS-1$ |
| if (item instanceof TableColumn) { |
| result = ((TableColumn) item).getText(); |
| if (result.trim().equals("")) { //$NON-NLS-1$ |
| result = ((TableColumn) item).getToolTipText(); |
| } |
| } else if (item instanceof TreeColumn) { |
| result = ((TreeColumn) item).getText(); |
| if (result.trim().equals("")) { //$NON-NLS-1$ |
| result = ((TreeColumn) item).getToolTipText(); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * @param item |
| * @return |
| */ |
| private int getColumnWidth(Item item) { |
| if (item instanceof TableColumn) { |
| return ((TableColumn) item).getWidth(); |
| } else if (item instanceof TreeColumn) { |
| return ((TreeColumn) item).getWidth(); |
| } |
| return 0; |
| } |
| |
| /** |
| * @return |
| */ |
| private Item[] getViewerColumns() { |
| if (targetControl instanceof Table) { |
| return ((Table) targetControl).getColumns(); |
| } else if (targetControl instanceof Tree) { |
| return ((Tree) targetControl).getColumns(); |
| } |
| return new Item[0]; |
| } |
| |
| private void handleSelectionChanged(int index) { |
| ColumnObject c = columnObjects[index]; |
| text.setText(Integer.toString(c.width)); |
| text.setEnabled(c.resizable); |
| if (moveableColumnsFound) { |
| upButton.setEnabled(c.moveable && index > 0); |
| downButton.setEnabled(c.moveable |
| && index + 1 < table.getItemCount()); |
| } |
| } |
| |
| protected void okPressed() { |
| int[] columnOrder = new int[columnObjects.length]; |
| for (int i = 0; i < columnObjects.length; i++) { |
| ColumnObject columnObject = columnObjects[i]; |
| columnOrder[i] = columnObject.index; |
| setColumnWidth(columnObject.column, columnObject.width); |
| } |
| setColumnOrder(columnOrder); |
| super.okPressed(); |
| } |
| |
| /** |
| * @param column |
| * @param width |
| */ |
| private void setColumnWidth(Item item, int width) { |
| if (item instanceof TableColumn) { |
| ((TableColumn) item).setWidth(width); |
| } else if (item instanceof TreeColumn) { |
| ((TreeColumn) item).setWidth(width); |
| } |
| } |
| |
| /** |
| * @param columnOrder |
| */ |
| private void setColumnOrder(int[] order) { |
| if (targetControl instanceof Table) { |
| ((Table) targetControl).setColumnOrder(order); |
| } else if (targetControl instanceof Tree) { |
| ((Tree) targetControl).setColumnOrder(order); |
| } |
| } |
| } |