/*******************************************************************************
 * Copyright (c) 2006 Sybase, Inc. 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:
 *     Sybase, Inc. - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.pagedesigner.properties.celleditors;

import java.text.MessageFormat;

import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ICellEditorListener;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Layout;
import org.eclipse.swt.widgets.Listener;

/**
 * CellEditorWrapper is a special cell editor, that wraps an existing cell
 * editor by adding a small clickable button to end of it.
 * 
 * Due to limitation of the CellEditor framework, this wrapping technology may
 * resulting in some small inconvenience when change focus from the "wrapped"
 * cell editor to the "added" button.
 * 
 * This is an abstract class. Child class need override some methods.
 * 
 * @author mengbo
 */
public abstract class CellEditorWrapper extends CellEditor {
	/**
	 * The editor control.
	 */
	private Composite _editor;

	/**
	 * the wrapped cell editor
	 */
	private CellEditor _wrapped;

	/**
	 * The button.
	 */
	private Button _button;

	/**
	 * Internal class for laying out the dialog.
	 */
	private class DialogCellLayout extends Layout {
		public void layout(Composite editor, boolean force) {
			Rectangle bounds = editor.getClientArea();
			Point size = _button.computeSize(SWT.DEFAULT, SWT.DEFAULT, force);
			// if (_wrapped != null)
			_wrapped.getControl().setBounds(0, 0, bounds.width - size.x,
					bounds.height);
			_button.setBounds(bounds.width - size.x, 0, size.x, bounds.height);
		}

		public Point computeSize(Composite editor, int wHint, int hHint,
				boolean force) {
			if (wHint != SWT.DEFAULT && hHint != SWT.DEFAULT)
				return new Point(wHint, hHint);
			Point contentsSize = _wrapped.getControl().computeSize(SWT.DEFAULT,
					SWT.DEFAULT, force);
			Point buttonSize = _button.computeSize(SWT.DEFAULT, SWT.DEFAULT,
					force);
			// Just return the button width to ensure the button is not clipped
			// if the label is long.
			// The label will just use whatever extra width there is
			Point result = new Point(buttonSize.x, Math.max(contentsSize.y,
					buttonSize.y));
			return result;
		}
	}

	/**
	 * Default DialogCellEditor style
	 */
	private static final int defaultStyle = SWT.NONE;

	/**
	 * Creates a new dialog cell editor with no control
	 * 
	 * @since 2.1
	 */
	public CellEditorWrapper() {
		setStyle(defaultStyle);
	}

	/**
	 * Creates a new dialog cell editor parented under the given control. The
	 * cell editor value is <code>null</code> initially, and has no validator.
	 * 
	 * @param parent
	 *            the parent control
	 */
	protected CellEditorWrapper(Composite parent) {
		this(parent, defaultStyle);
	}

	/**
	 * Creates a new dialog cell editor parented under the given control. The
	 * cell editor value is <code>null</code> initially, and has no validator.
	 * 
	 * @param parent
	 *            the parent control
	 * @param style
	 *            the style bits
	 * @since 2.1
	 */
	protected CellEditorWrapper(Composite parent, int style) {
		super(parent, style);
	}

	/**
	 * Creates the button for this cell editor under the given parent control.
	 * <p>
	 * The default implementation of this framework method creates the button
	 * display on the right hand side of the dialog cell editor. Subclasses may
	 * extend or reimplement.
	 * </p>
	 * 
	 * @param parent
	 *            the parent control
	 * @return the new button control
	 */
	protected Button createButton(Composite parent) {
		Button result = new Button(parent, SWT.DOWN);
		result.setImage(getBindingImage());
		// result.setText("..."); //$NON-NLS-1$
		return result;
	}

	/**
	 * Since createButton is called from constructor, so we could only let child
	 * class override this method to provide image. Rather than setting as
	 * property.
	 * 
	 * @return image
	 */
	protected abstract Image getBindingImage();

	/**
	 * Creates the controls used to show the value of this cell editor.
	 * <p>
	 * The default implementation of this framework method creates a label
	 * widget, using the same font and background color as the parent control.
	 * </p>
	 * <p>
	 * Subclasses may re-implement. If you re-implement this method, you should
	 * also re-implement <code>updateContents</code>.
	 * </p>
	 * 
	 * @param cell
	 *            the control for this cell editor
	 * @return control
	 */
	protected Control createContents(Composite cell) {
		_wrapped = createWrappedCellEditor(cell);
		if (_wrapped == null) {
			_wrapped = new TextCellEditor(cell);
		}
		_wrapped.addListener(new ICellEditorListener() {
			public void applyEditorValue() {
				fireApplyEditorValue();
			}

			public void cancelEditor() {
				fireCancelEditor();
			}

			public void editorValueChanged(boolean oldValidState,
					boolean newValidState) {
				fireEditorValueChanged(oldValidState, newValidState);
			}
		});
		_wrapped.addPropertyChangeListener(new IPropertyChangeListener() {
			public void propertyChange(PropertyChangeEvent event) {
				// FIXME:
			}
		});

		_wrapped.getControl().setVisible(true);
		_wrapped.getControl().addListener(SWT.Hide, new Listener() {
			public void handleEvent(Event event) {
				Display.getCurrent().asyncExec(new Runnable() {
					public void run() {
						if (_wrapped != null && _wrapped.getControl() != null
								&& !_wrapped.getControl().isDisposed()) {
							_wrapped.getControl().setVisible(true);
						} else {
							deactivate();
						}
					}
				});

			}
		});
		return _wrapped.getControl();
	}

	/**
	 * @param cell
	 * @return CellEditor
	 */
	protected abstract CellEditor createWrappedCellEditor(Composite cell);

	/*
	 * (non-Javadoc) Method declared on CellEditor.
	 */
	protected Control createControl(Composite parent) {
		Font font = parent.getFont();
		Color bg = parent.getBackground();

		_editor = new Composite(parent, getStyle());
		_editor.setFont(font);
		_editor.setBackground(bg);
		_editor.setLayout(new DialogCellLayout());

		createContents(_editor);
		// updateContents(value);

		_button = createButton(_editor);
		_button.setFont(font);

		_button.addKeyListener(new KeyAdapter() {
			public void keyReleased(KeyEvent e) {
				if (e.character == '\u001b') { // Escape
					fireCancelEditor();
				}
			}
		});

		_button.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent event) {
				Object newValue = openDialogBox(_editor);
				if (newValue != null) {
					boolean newValidState = isCorrect(newValue);
					if (newValidState) {
						markDirty();
						doSetValue(newValue);
					} else {
						// try to insert the current value into the error
						// message.
						setErrorMessage(MessageFormat.format(getErrorMessage(),
								new Object[] { newValue.toString() }));
					}
					fireApplyEditorValue();
				}
			}
		});

		setValueValid(true);

		return _editor;
	}

	/*
	 * (non-Javadoc) Method declared on CellEditor. The focus is set to the cell
	 * editor's button.
	 */
	protected void doSetFocus() {
		if (_wrapped != null && _wrapped.getControl() != null
				&& !_wrapped.getControl().isDisposed()) {
			_wrapped.setFocus();
		} else {
			_button.setFocus();
		}
	}

	/*
	 * (non-Javadoc) Method declared on CellEditor.
	 */
	protected Object doGetValue() {
		return _wrapped.getValue();
	}

	/*
	 * (non-Javadoc) Method declared on CellEditor.
	 */
	protected void doSetValue(Object value) {
		if (_wrapped != null) {
			_wrapped.setValue(value);
		}
	}

	/**
	 * Opens a dialog box under the given parent control and returns the
	 * dialog's value when it closes, or <code>null</code> if the dialog was
	 * cancelled or no selection was made in the dialog.
	 * <p>
	 * This framework method must be implemented by concrete subclasses. It is
	 * called when the user has pressed the button and the dialog box must pop
	 * up.
	 * </p>
	 * 
	 * @param cellEditorWindow
	 *            the parent control cell editor's window so that a subclass can
	 *            adjust the dialog box accordingly
	 * @return the selected value, or <code>null</code> if the dialog was
	 *         cancelled or no selection was made in the dialog
	 */
	protected abstract Object openDialogBox(Control cellEditorWindow);

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.CellEditor#activate()
	 */
	public void activate() {
		super.activate();
		_wrapped.activate();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.CellEditor#deactivate()
	 */
	public void deactivate() {
		super.deactivate();
		// if (_wrapped != null)
		// {
		// _wrapped.deactivate();
		// }
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.CellEditor#dispose()
	 */
	public void dispose() {
		_wrapped.dispose();
		super.dispose();
	}

}