/*******************************************************************************
 * Copyright (c) 2000, 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
 *     Tom Schindl <tom.schindl@bestsolution.at> - bug 153993
 *******************************************************************************/

package org.eclipse.jface.viewers;

import java.util.List;

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.TableTree;
import org.eclipse.swt.custom.TableTreeEditor;
import org.eclipse.swt.custom.TableTreeItem;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.TreeListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
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.Widget;

/**
 * A concrete viewer based on a SWT <code>TableTree</code> control.
 * <p>
 * This class is not intended to be subclassed outside the viewer framework. It
 * is designed to be instantiated with a pre-existing SWT table tree control and
 * configured with a domain-specific content provider, label provider, element
 * filter (optional), and element sorter (optional).
 * </p>
 * <p>
 * Content providers for table tree viewers must implement the
 * <code>ITreeContentProvider</code> interface.
 * </p>
 * <p>
 * Label providers for table tree viewers must implement either the
 * <code>ITableLabelProvider</code> or the <code>ILabelProvider</code>
 * interface (see <code>TableTreeViewer.setLabelProvider</code> for more
 * details).
 * </p>
 * 
 * @deprecated As of 3.1 use {@link TreeViewer} instead
 * @noextend This class is not intended to be subclassed by clients.
 */
public class TableTreeViewer extends AbstractTreeViewer {
	/**
	 * Internal table viewer implementation.
	 */
	private TableTreeEditorImpl tableEditorImpl;

	/**
	 * This viewer's table tree control.
	 */
	private TableTree tableTree;

	/**
	 * This viewer's table tree editor.
	 */
	private TableTreeEditor tableTreeEditor;

	/**
	 * Copied from original TableEditorImpl and moved here since refactoring
	 * completely wiped out the original implementation in 3.3
	 * 
	 * @since 3.1
	 */
	class TableTreeEditorImpl {

		private CellEditor cellEditor;

		private CellEditor[] cellEditors;

		private ICellModifier cellModifier;

		private String[] columnProperties;

		private Item tableItem;

		private int columnNumber;

		private ICellEditorListener cellEditorListener;

		private FocusListener focusListener;

		private MouseListener mouseListener;

		private int doubleClickExpirationTime;

		private ColumnViewer viewer;

		private TableTreeEditorImpl(ColumnViewer viewer) {
			this.viewer = viewer;
			initCellEditorListener();
		}

		/**
		 * Returns this <code>TableViewerImpl</code> viewer
		 * 
		 * @return the viewer
		 */
		public ColumnViewer getViewer() {
			return viewer;
		}

		private void activateCellEditor() {
			if( cellEditors != null ) {
				if( cellEditors[columnNumber] != null && cellModifier != null ) {
					Object element = tableItem.getData();
					String property = columnProperties[columnNumber];
					
					if( cellModifier.canModify(element, property) ) {
						cellEditor = cellEditors[columnNumber];
						
						cellEditor.addListener(cellEditorListener);
						
						Object value = cellModifier.getValue(element, property);
						cellEditor.setValue(value);
						// Tricky flow of control here:
						// activate() can trigger callback to cellEditorListener
						// which will clear cellEditor
						// so must get control first, but must still call activate()
						// even if there is no control.
						final Control control = cellEditor.getControl();
						cellEditor.activate();
						if (control == null) {
							return;
						}
						setLayoutData(cellEditor.getLayoutData());
						setEditor(control, tableItem, columnNumber);
						cellEditor.setFocus();
						if (focusListener == null) {
							focusListener = new FocusAdapter() {
								public void focusLost(FocusEvent e) {
									applyEditorValue();
								}
							};
						}
						control.addFocusListener(focusListener);
						mouseListener = new MouseAdapter() {
							public void mouseDown(MouseEvent e) {
								// time wrap?
								// check for expiration of doubleClickTime
								if (e.time <= doubleClickExpirationTime) {
									control.removeMouseListener(mouseListener);
									cancelEditing();
									handleDoubleClickEvent();
								} else if (mouseListener != null) {
									control.removeMouseListener(mouseListener);
								}
							}
						};
						control.addMouseListener(mouseListener);
					}
				}
			}
		}

		/**
		 * Activate a cell editor for the given mouse position.
		 */
		private void activateCellEditor(MouseEvent event) {
			if (tableItem == null || tableItem.isDisposed()) {
				// item no longer exists
				return;
			}
			int columnToEdit;
			int columns = getColumnCount();
			if (columns == 0) {
				// If no TableColumn, Table acts as if it has a single column
				// which takes the whole width.
				columnToEdit = 0;
			} else {
				columnToEdit = -1;
				for (int i = 0; i < columns; i++) {
					Rectangle bounds = getBounds(tableItem, i);
					if (bounds.contains(event.x, event.y)) {
						columnToEdit = i;
						break;
					}
				}
				if (columnToEdit == -1) {
					return;
				}
			}

			columnNumber = columnToEdit;
			activateCellEditor();
		}

		/**
		 * Deactivates the currently active cell editor.
		 */
		public void applyEditorValue() {
			CellEditor c = this.cellEditor;
			if (c != null) {
				// null out cell editor before calling save
				// in case save results in applyEditorValue being re-entered
				// see 1GAHI8Z: ITPUI:ALL - How to code event notification when
				// using cell editor ?
				this.cellEditor = null;
				Item t = this.tableItem;
				// don't null out table item -- same item is still selected
				if (t != null && !t.isDisposed()) {
					saveEditorValue(c, t);
				}
				setEditor(null, null, 0);
				c.removeListener(cellEditorListener);
				Control control = c.getControl();
				if (control != null) {
					if (mouseListener != null) {
						control.removeMouseListener(mouseListener);
					}
					if (focusListener != null) {
						control.removeFocusListener(focusListener);
					}
				}
				c.deactivate();
			}
		}

		/**
		 * Cancels the active cell editor, without saving the value back to the
		 * domain model.
		 */
		public void cancelEditing() {
			if (cellEditor != null) {
				setEditor(null, null, 0);
				cellEditor.removeListener(cellEditorListener);
				CellEditor oldEditor = cellEditor;
				cellEditor = null;
				oldEditor.deactivate();
			}
		}

		/**
		 * Start editing the given element.
		 * 
		 * @param element
		 * @param column
		 */
		public void editElement(Object element, int column) {
			if (cellEditor != null) {
				applyEditorValue();
			}

			setSelection(new StructuredSelection(element), true);
			Item[] selection = getSelection();
			if (selection.length != 1) {
				return;
			}

			tableItem = selection[0];

			// Make sure selection is visible
			showSelection();
			columnNumber = column;
			activateCellEditor();

		}

		/**
		 * Return the array of CellEditors used in the viewer
		 * 
		 * @return the cell editors
		 */
		public CellEditor[] getCellEditors() {
			return cellEditors;
		}

		/**
		 * Get the cell modifier
		 * 
		 * @return the cell modifier
		 */
		public ICellModifier getCellModifier() {
			return cellModifier;
		}

		/**
		 * Return the properties for the column
		 * 
		 * @return the array of column properties
		 */
		public Object[] getColumnProperties() {
			return columnProperties;
		}

		/**
		 * Handles the mouse down event; activates the cell editor.
		 * 
		 * @param event
		 *            the mouse event that should be handled
		 */
		public void handleMouseDown(MouseEvent event) {
			if (event.button != 1) {
				return;
			}

			if (cellEditor != null) {
				applyEditorValue();
			}

			// activate the cell editor immediately. If a second mouseDown
			// is received prior to the expiration of the doubleClick time then
			// the cell editor will be deactivated and a doubleClick event will
			// be processed.
			//
			doubleClickExpirationTime = event.time
					+ Display.getCurrent().getDoubleClickTime();

			Item[] items = getSelection();
			// Do not edit if more than one row is selected.
			if (items.length != 1) {
				tableItem = null;
				return;
			}
			tableItem = items[0];
			
			activateCellEditor(event);
		}

		private void initCellEditorListener() {
			cellEditorListener = new ICellEditorListener() {
				public void editorValueChanged(boolean oldValidState,
						boolean newValidState) {
					// Ignore.
				}

				public void cancelEditor() {
					TableTreeEditorImpl.this.cancelEditing();
				}

				public void applyEditorValue() {
					TableTreeEditorImpl.this.applyEditorValue();
				}
			};
		}

		/**
		 * Return whether there is an active cell editor.
		 * 
		 * @return <code>true</code> if there is an active cell editor;
		 *         otherwise <code>false</code> is returned.
		 */
		public boolean isCellEditorActive() {
			return cellEditor != null;
		}

		/**
		 * Saves the value of the currently active cell editor, by delegating to
		 * the cell modifier.
		 */
		private void saveEditorValue(CellEditor cellEditor, Item tableItem) {
			if( cellModifier != null ) {
				if( ! cellEditor.isValueValid() ) {
					// Do what????
				}
			}
			String property = null;
			
			if( columnProperties != null && columnNumber < columnProperties.length ) {
				property = columnProperties[columnNumber];
			}
			cellModifier.modify(tableItem, property, cellEditor.getValue());
		}

		/**
		 * Set the cell editors
		 * 
		 * @param editors
		 */
		public void setCellEditors(CellEditor[] editors) {
			this.cellEditors = editors;
		}

		/**
		 * Set the cell modifier
		 * 
		 * @param modifier
		 */
		public void setCellModifier(ICellModifier modifier) {
			this.cellModifier = modifier;
		}

		/**
		 * Set the column properties
		 * 
		 * @param columnProperties
		 */
		public void setColumnProperties(String[] columnProperties) {
			this.columnProperties = columnProperties;
		}

		Rectangle getBounds(Item item, int columnNumber) {
			return ((TableTreeItem) item).getBounds(columnNumber);
		}

		int getColumnCount() {
			// getColumnCount() should be a API in TableTree.
			return getTableTree().getTable().getColumnCount();
		}

		Item[] getSelection() {
			return getTableTree().getSelection();
		}

		void setEditor(Control w, Item item, int columnNumber) {
			tableTreeEditor.setEditor(w, (TableTreeItem) item, columnNumber);
		}

		void setSelection(StructuredSelection selection, boolean b) {
			TableTreeViewer.this.setSelection(selection, b);
		}

		void showSelection() {
			getTableTree().showSelection();
		}

		void setLayoutData(CellEditor.LayoutData layoutData) {
			tableTreeEditor.horizontalAlignment = layoutData.horizontalAlignment;
			tableTreeEditor.grabHorizontal = layoutData.grabHorizontal;
			tableTreeEditor.minimumWidth = layoutData.minimumWidth;
		}

		void handleDoubleClickEvent() {
			Viewer viewer = getViewer();
			fireDoubleClick(new DoubleClickEvent(viewer, viewer.getSelection()));
			fireOpen(new OpenEvent(viewer, viewer.getSelection()));
		}
	}

	/**
	 * Creates a table tree viewer on the given table tree control. The viewer
	 * has no input, no content provider, a default label provider, no sorter,
	 * and no filters.
	 * 
	 * @param tree
	 *            the table tree control
	 */
	public TableTreeViewer(TableTree tree) {
		super();
		tableTree = tree;
		hookControl(tree);
		tableTreeEditor = new TableTreeEditor(tableTree);
		tableEditorImpl = new TableTreeEditorImpl(this);
	}

	/**
	 * Creates a table tree viewer on a newly-created table tree control under
	 * the given parent. The table tree control is created using the SWT style
	 * bits <code>MULTI, H_SCROLL, V_SCROLL, and BORDER</code>. The viewer
	 * has no input, no content provider, a default label provider, no sorter,
	 * and no filters.
	 * 
	 * @param parent
	 *            the parent control
	 */
	public TableTreeViewer(Composite parent) {
		this(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
	}

	/**
	 * Creates a table tree viewer on a newly-created table tree control under
	 * the given parent. The table tree control is created using the given SWT
	 * style bits. The viewer has no input, no content provider, a default label
	 * provider, no sorter, and no filters.
	 * 
	 * @param parent
	 *            the parent control
	 * @param style
	 *            the SWT style bits
	 */
	public TableTreeViewer(Composite parent, int style) {
		this(new TableTree(parent, style));
	}

	/*
	 * (non-Javadoc) Method declared on AbstractTreeViewer.
	 */
	protected void addTreeListener(Control c, TreeListener listener) {
		((TableTree) c).addTreeListener(listener);
	}

	/**
	 * Cancels a currently active cell editor. All changes already done in the
	 * cell editor are lost.
	 */
	public void cancelEditing() {
		tableEditorImpl.cancelEditing();
	}

	/*
	 * (non-Javadoc) Method declared on AbstractTreeViewer.
	 */
	protected void doUpdateItem(Item item, Object element) {
		// update icon and label
		// Similar code in TableTreeViewer.doUpdateItem()
		IBaseLabelProvider prov = getLabelProvider();
		ITableLabelProvider tprov = null;

		if (prov instanceof ITableLabelProvider) {
			tprov = (ITableLabelProvider) prov;
		}

		int columnCount = tableTree.getTable().getColumnCount();
		TableTreeItem ti = (TableTreeItem) item;
		// Also enter loop if no columns added. See 1G9WWGZ: JFUIF:WINNT -
		// TableViewer with 0 columns does not work
		for (int column = 0; column < columnCount || column == 0; column++) {
			String text = "";//$NON-NLS-1$
			Image image = null;
			if (tprov != null) {
				text = tprov.getColumnText(element, column);
				image = tprov.getColumnImage(element, column);
			} else {
				if (column == 0) {
					ViewerLabel updateLabel = new ViewerLabel(item.getText(),
							item.getImage());
					buildLabel(updateLabel, element);

					// As it is possible for user code to run the event
					// loop check here.
					if (item.isDisposed()) {
						unmapElement(element, item);
						return;
					}

					text = updateLabel.getText();
					image = updateLabel.getImage();
				}
			}

			// Avoid setting text to null
			if (text == null) {
				text = ""; //$NON-NLS-1$
			}

			ti.setText(column, text);
			// Apparently a problem to setImage to null if already null
			if (ti.getImage(column) != image) {
				ti.setImage(column, image);
			}

			getColorAndFontCollector().setFontsAndColors(element);
			getColorAndFontCollector().applyFontsAndColors(ti);
		}

	}

	/**
	 * Starts editing the given element.
	 * 
	 * @param element
	 *            the element
	 * @param column
	 *            the column number
	 */
	public void editElement(Object element, int column) {
		tableEditorImpl.editElement(element, column);
	}

	/**
	 * Returns the cell editors of this viewer.
	 * 
	 * @return the list of cell editors
	 */
	public CellEditor[] getCellEditors() {
		return tableEditorImpl.getCellEditors();
	}

	/**
	 * Returns the cell modifier of this viewer.
	 * 
	 * @return the cell modifier
	 */
	public ICellModifier getCellModifier() {
		return tableEditorImpl.getCellModifier();
	}

	/*
	 * (non-Javadoc) Method declared on AbstractTreeViewer.
	 */
	protected Item[] getChildren(Widget o) {
		if (o instanceof TableTreeItem) {
			return ((TableTreeItem) o).getItems();
		}
		if (o instanceof TableTree) {
			return ((TableTree) o).getItems();
		}
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.AbstractTreeViewer#getChild(org.eclipse.swt.widgets.Widget,
	 *      int)
	 */
	protected Item getChild(Widget widget, int index) {
		if (widget instanceof TableTreeItem) {
			return ((TableTreeItem) widget).getItem(index);
		}
		if (widget instanceof TableTree) {
			return ((TableTree) widget).getItem(index);
		}
		return null;
	}

	/**
	 * Returns the column properties of this viewer. The properties must
	 * correspond with the columns of the table control. They are used to
	 * identify the column in a cell modifier.
	 * 
	 * @return the list of column properties
	 */
	public Object[] getColumnProperties() {
		return tableEditorImpl.getColumnProperties();
	}

	/*
	 * (non-Javadoc) Method declared on Viewer.
	 */
	public Control getControl() {
		return tableTree;
	}

	/**
	 * Returns the element with the given index from this viewer. Returns
	 * <code>null</code> if the index is out of range.
	 * <p>
	 * This method is internal to the framework.
	 * </p>
	 * 
	 * @param index
	 *            the zero-based index
	 * @return the element at the given index, or <code>null</code> if the
	 *         index is out of range
	 */
	public Object getElementAt(int index) {
		// XXX: Workaround for 1GBCSB1: SWT:WIN2000 - TableTree should have
		// getItem(int index)
		TableTreeItem i = tableTree.getItems()[index];
		if (i != null) {
			return i.getData();
		}
		return null;
	}

	/*
	 * (non-Javadoc) Method declared on AbstractTreeViewer.
	 */
	protected boolean getExpanded(Item item) {
		return ((TableTreeItem) item).getExpanded();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.ColumnViewer#getItemAt(org.eclipse.swt.graphics.Point)
	 */
	protected Item getItemAt(Point p) {
		return getTableTree().getTable().getItem(p);
	}

	/*
	 * (non-Javadoc) Method declared on AbstractTreeViewer.
	 */
	protected int getItemCount(Control widget) {
		return ((TableTree) widget).getItemCount();
	}

	/*
	 * (non-Javadoc) Method declared on AbstractTreeViewer.
	 */
	protected int getItemCount(Item item) {
		return ((TableTreeItem) item).getItemCount();
	}

	/*
	 * (non-Javadoc) Method declared on AbstractTreeViewer.
	 */
	protected org.eclipse.swt.widgets.Item[] getItems(
			org.eclipse.swt.widgets.Item item) {
		return ((TableTreeItem) item).getItems();
	}

	/**
	 * The table tree viewer implementation of this <code>Viewer</code>
	 * framework method returns the label provider, which in the case of table
	 * tree viewers will be an instance of either
	 * <code>ITableLabelProvider</code> or <code>ILabelProvider</code>. If
	 * it is an <code>ITableLabelProvider</code>, then it provides a separate
	 * label text and image for each column. If it is an
	 * <code>ILabelProvider</code>, then it provides only the label text and
	 * image for the first column, and any remaining columns are blank.
	 */
	public IBaseLabelProvider getLabelProvider() {
		return super.getLabelProvider();
	}

	/*
	 * (non-Javadoc) Method declared on AbstractTreeViewer.
	 */
	protected Item getParentItem(Item item) {
		return ((TableTreeItem) item).getParentItem();
	}

	/*
	 * (non-Javadoc) Method declared on AbstractTreeViewer.
	 */
	protected Item[] getSelection(Control widget) {
		return ((TableTree) widget).getSelection();
	}

	/**
	 * Returns this table tree viewer's table tree control.
	 * 
	 * @return the table tree control
	 */
	public TableTree getTableTree() {
		return tableTree;
	}

	/*
	 * (non-Javadoc) Method declared on AbstractTreeViewer.
	 */
	protected void hookControl(Control control) {
		super.hookControl(control);
		tableTree.getTable().addMouseListener(new MouseAdapter() {
			public void mouseDown(MouseEvent e) {
				/*
				 * If user clicked on the [+] or [-], do not activate
				 * CellEditor.
				 */
				// XXX: This code should not be here. SWT should either have
				// support to see
				// if the user clicked on the [+]/[-] or manage the table editor
				// activation
				org.eclipse.swt.widgets.TableItem[] items = tableTree
						.getTable().getItems();
				for (int i = 0; i < items.length; i++) {
					Rectangle rect = items[i].getImageBounds(0);
					if (rect.contains(e.x, e.y)) {
						return;
					}
				}

				tableEditorImpl.handleMouseDown(e);
			}
		});
	}

	/**
	 * Returns whether there is an active cell editor.
	 * 
	 * @return <code>true</code> if there is an active cell editor, and
	 *         <code>false</code> otherwise
	 */
	public boolean isCellEditorActive() {
		return tableEditorImpl.isCellEditorActive();
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected Item newItem(Widget parent, int flags, int ix) {
		TableTreeItem item;
		if (ix >= 0) {
			if (parent instanceof TableTreeItem) {
				item = new TableTreeItem((TableTreeItem) parent, flags, ix);
			} else {
				item = new TableTreeItem((TableTree) parent, flags, ix);
			}
		} else {
			if (parent instanceof TableTreeItem) {
				item = new TableTreeItem((TableTreeItem) parent, flags);
			} else {
				item = new TableTreeItem((TableTree) parent, flags);
			}
		}
		return item;
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected void removeAll(Control widget) {
		((TableTree) widget).removeAll();
	}

	/**
	 * Sets the cell editors of this table viewer.
	 * 
	 * @param editors
	 *            the list of cell editors
	 */
	public void setCellEditors(CellEditor[] editors) {
		tableEditorImpl.setCellEditors(editors);
	}

	/**
	 * Sets the cell modifier of this table viewer.
	 * 
	 * @param modifier
	 *            the cell modifier
	 */
	public void setCellModifier(ICellModifier modifier) {
		tableEditorImpl.setCellModifier(modifier);
	}

	/**
	 * Sets the column properties of this table viewer. The properties must
	 * correspond with the columns of the table control. They are used to
	 * identify the column in a cell modifier.
	 * 
	 * @param columnProperties
	 *            the list of column properties
	 */
	public void setColumnProperties(String[] columnProperties) {
		tableEditorImpl.setColumnProperties(columnProperties);
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected void setExpanded(Item node, boolean expand) {
		((TableTreeItem) node).setExpanded(expand);
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected void setSelection(List items) {
		TableTreeItem[] newItems = new TableTreeItem[items.size()];
		items.toArray(newItems);
		getTableTree().setSelection(newItems);
	}

	/*
	 * (non-Javadoc) Method declared in AbstractTreeViewer.
	 */
	protected void showItem(Item item) {
		getTableTree().showItem((TableTreeItem) item);
	}
}
