/*******************************************************************************
 * Copyright (c) 2000, 2010 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
 *     Benjamin Muskalla -	Bug 29633 [EditorMgmt] "Open" menu should
 *     						have Open With-->Other
 *     Helena Halperin - Bug 298747 [EditorMgmt] Bidi Incorrect file type direction in mirrored "Editor Selection" dialog
 *******************************************************************************/
package org.eclipse.ui.dialogs;

import java.util.ArrayList;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.resource.LocalResourceManager;
import org.eclipse.jface.resource.ResourceManager;
import org.eclipse.jface.util.Util;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.osgi.util.TextProcessor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
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.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.ui.IEditorDescriptor;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.IWorkbenchHelpContextIds;
import org.eclipse.ui.internal.WorkbenchMessages;
import org.eclipse.ui.internal.WorkbenchPlugin;
import org.eclipse.ui.internal.registry.EditorDescriptor;
import org.eclipse.ui.internal.registry.EditorRegistry;


/**
 * This class is used to allow the user to select a dialog from the set of
 * internal and external editors.
 * 
 * @since 1.1
 *
 */

public final class EditorSelectionDialog extends Dialog {
	private EditorDescriptor selectedEditor;

// RAP [rh] external editors not supported: therefore externalButton,
//     internalButton and browseExternalEditorsButton are unnecessary
//	private Button externalButton;

	private Table editorTable;

//	private Button browseExternalEditorsButton;

//	private Button internalButton;

	private Button okButton;

//RAP [rh] unused code due to changes becauase of external editors not supported
//	private static final String STORE_ID_INTERNAL_EXTERNAL = "EditorSelectionDialog.STORE_ID_INTERNAL_EXTERNAL";//$NON-NLS-1$

	private String message = WorkbenchMessages.get().EditorSelection_chooseAnEditor;

	// RAP [bm]: no external editors
	// collection of IEditorDescriptor
//	private IEditorDescriptor[] externalEditors;

	private IEditorDescriptor[] internalEditors;

	private IEditorDescriptor[] editorsToFilter;

	private DialogListener listener = new DialogListener();

	private ResourceManager resourceManager;

	private TableViewer editorTableViewer;

// RAP [rh] external editors not supported
//	private static final String[] Executable_Filters;

	private static final int TABLE_WIDTH = 200;
//RAP [rh] external editors not supported
//	static {
//		if (SWT.getPlatform().equals("win32")) {//$NON-NLS-1$
//			Executable_Filters = new String[] { "*.exe", "*.bat", "*.*" };//$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
//		} else {
//			Executable_Filters = new String[] { "*" }; //$NON-NLS-1$
//		}
//	}

	/**
	 * Create an instance of this class.
	 *
	 * @param parentShell
	 *            the parent shell
	 */
	public EditorSelectionDialog(Shell parentShell) {
		super(parentShell);
		resourceManager = new LocalResourceManager(JFaceResources.getResources(parentShell
				.getDisplay()));
	}

	/**
	 * This method is called if a button has been pressed.
	 */
	protected void buttonPressed(int buttonId) {
		if (buttonId == IDialogConstants.OK_ID) {
			saveWidgetValues();
		}
		super.buttonPressed(buttonId);
	}

	/**
	 * Close the window.
	 */
	public boolean close() {
		boolean result = super.close();
		resourceManager.dispose();
		resourceManager = null;
		return result;
	}

	/*
	 * (non-Javadoc) Method declared in Window.
	 */
	protected void configureShell(Shell shell) {
		super.configureShell(shell);
		shell.setText(WorkbenchMessages.get().EditorSelection_title);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(shell,
				IWorkbenchHelpContextIds.EDITOR_SELECTION_DIALOG);
	}

	/**
	 * Creates and returns the contents of the upper part of the dialog (above
	 * the button bar).
	 *
	 * Subclasses should overide.
	 *
	 * @param parent
	 *            the parent composite to contain the dialog area
	 * @return the dialog area control
	 */
	protected Control createDialogArea(Composite parent) {
		Font font = parent.getFont();
		// create main group
		Composite contents = (Composite) super.createDialogArea(parent);
		((GridLayout) contents.getLayout()).numColumns = 2;

		// begin the layout
		Label textLabel = new Label(contents, SWT.NONE);
		textLabel.setText(message);
		GridData data = new GridData();
		data.horizontalSpan = 2;
		textLabel.setLayoutData(data);
		textLabel.setFont(font);

// RAP [rh] external editors not supported
//		internalButton = new Button(contents, SWT.RADIO | SWT.LEFT);
//		internalButton.setText(WorkbenchMessages.EditorSelection_internal);
//		internalButton.addListener(SWT.Selection, listener);
//		data = new GridData();
//		data.horizontalSpan = 1;
//		internalButton.setLayoutData(data);
//		internalButton.setFont(font);
//
//		externalButton = new Button(contents, SWT.RADIO | SWT.LEFT);
//		externalButton.setText(WorkbenchMessages.EditorSelection_external);
//		externalButton.addListener(SWT.Selection, listener);
//		data = new GridData();
//		data.horizontalSpan = 1;
//		externalButton.setLayoutData(data);
//		externalButton.setFont(font);

		editorTable = new Table(contents, SWT.SINGLE | SWT.BORDER);
		data = new GridData();
		data.widthHint = convertHorizontalDLUsToPixels(TABLE_WIDTH);
		data.horizontalAlignment = GridData.FILL;
		data.grabExcessHorizontalSpace = true;
		data.verticalAlignment = GridData.FILL;
		data.grabExcessVerticalSpace = true;
		data.horizontalSpan = 2;
		editorTable.setLayoutData(data);
		editorTable.setFont(font);
		data.heightHint = editorTable.getItemHeight() * 12;
		editorTableViewer = new TableViewer(editorTable);
		editorTableViewer.setContentProvider(ArrayContentProvider.getInstance());
		editorTableViewer.setLabelProvider(new LabelProvider() {
			public String getText(Object element) {
				IEditorDescriptor d = (IEditorDescriptor) element;
				return TextProcessor.process(d.getLabel(), "."); //$NON-NLS-1$
			}

			public Image getImage(Object element) {
				IEditorDescriptor d = (IEditorDescriptor) element;
				return (Image) resourceManager.get(d.getImageDescriptor());
			}
		});
		editorTable.addListener(SWT.Selection, listener);
		editorTable.addListener(SWT.DefaultSelection, listener);
		// RAP [rh] DblClickListener doesn't work reliable
//		editorTable.addListener(SWT.MouseDoubleClick, listener);
		editorTable.addListener(SWT.Selection, listener);
		editorTable.addListener(SWT.DefaultSelection, listener);
		editorTable.addListener(SWT.MouseDoubleClick, listener);

// RAP [rh] external editors not supported
//		browseExternalEditorsButton = new Button(contents, SWT.PUSH);
//		browseExternalEditorsButton
//				.setText(WorkbenchMessages.EditorSelection_browse);
//		browseExternalEditorsButton.addListener(SWT.Selection, listener);
//		data = new GridData();
//		int widthHint = convertHorizontalDLUsToPixels(IDialogConstants.BUTTON_WIDTH);
//		data.widthHint = Math.max(widthHint, browseExternalEditorsButton
//				.computeSize(SWT.DEFAULT, SWT.DEFAULT, true).x);
//		browseExternalEditorsButton.setLayoutData(data);
//		browseExternalEditorsButton.setFont(font);

		restoreWidgetValues(); // Place buttons to the appropriate state

		fillEditorTable();

		updateEnableState();

		return contents;
	}

	protected void fillEditorTable() {
		// RAP [bm] no external editors
//		if (internalButton.getSelection()) {
			editorTableViewer.setInput(getInternalEditors());
//		} else {
//			editorTableViewer.setInput(getExternalEditors());
//		}
	}

	/**
	 * Return the dialog store to cache values into
	 */

	protected IDialogSettings getDialogSettings() {
		IDialogSettings workbenchSettings = WorkbenchPlugin.getDefault()
				.getDialogSettings();
		IDialogSettings section = workbenchSettings
				.getSection("EditorSelectionDialog");//$NON-NLS-1$
		if (section == null) {
			section = workbenchSettings.addNewSection("EditorSelectionDialog");//$NON-NLS-1$
		}
		return section;
	}

	// RAP [bm]: no external editors
//	/**
//	 * Get a list of registered programs from the OS
//	 */
//	protected IEditorDescriptor[] getExternalEditors() {
//		if (externalEditors == null) {
//			// Since this can take a while, show the busy
//			// cursor. If the dialog is not yet visible,
//			// then use the parent shell.
//			Control shell = getShell();
//			if (!shell.isVisible()) {
//				Control topShell = shell.getParent();
//				if (topShell != null) {
//					shell = topShell;
//				}
//			}
//			//Cursor busy = new Cursor(shell.getDisplay(), SWT.CURSOR_WAIT);
//	        Cursor busy = Graphics.getCursor( SWT.CURSOR_WAIT );
//			shell.setCursor(busy);
//			// Get the external editors available
//			EditorRegistry reg = (EditorRegistry) WorkbenchPlugin.getDefault()
//					.getEditorRegistry();
//			externalEditors = reg.getSortedEditorsFromOS();
//			externalEditors = filterEditors(externalEditors);
//			externalEditorImages = getImages(externalEditors);
//			// Clean up
//			shell.setCursor(null);
//			//busy.dispose();
//		}
//		return externalEditors;
//	}

	/**
	 * Returns an array of editors which have been filtered according to the
	 * array of editors in the editorsToFilter instance variable.
	 *
	 * @param editors
	 *            an array of editors to filter
	 * @return a filtered array of editors
	 */
	protected IEditorDescriptor[] filterEditors(IEditorDescriptor[] editors) {
		if ((editors == null) || (editors.length < 1)) {
			return editors;
		}

		if ((editorsToFilter == null) || (editorsToFilter.length < 1)) {
			return editors;
		}

		ArrayList filteredList = new ArrayList();
		for (int i = 0; i < editors.length; i++) {
			boolean add = true;
			for (int j = 0; j < editorsToFilter.length; j++) {
				if (editors[i].getId().equals(editorsToFilter[j].getId())) {
					add = false;
				}
			}
			if (add) {
				filteredList.add(editors[i]);
			}
		}

		return (IEditorDescriptor[]) filteredList
				.toArray(new IEditorDescriptor[filteredList.size()]);
	}

	/**
	 * Returns the internal editors
	 */
	protected IEditorDescriptor[] getInternalEditors() {
		if (internalEditors == null) {
			EditorRegistry reg = (EditorRegistry) WorkbenchPlugin.getDefault()
					.getEditorRegistry();
			internalEditors = reg.getSortedEditorsFromPlugins();
			internalEditors = filterEditors(internalEditors);
		}
		return internalEditors;
	}

	/**
	 * Return the editor the user selected
	 *
	 * @return the selected editor
	 */
	public IEditorDescriptor getSelectedEditor() {
		return selectedEditor;
	}

// RAP [rh] external editors not supported
//	protected void promptForExternalEditor() {
//		FileDialog dialog = new FileDialog(getShell(), SWT.OPEN
//				| SWT.PRIMARY_MODAL | SWT.SHEET);
//		dialog.setFilterExtensions(Executable_Filters);
//		String result = dialog.open();
//		if (result != null) {
//			EditorDescriptor editor = EditorDescriptor.createForProgram(result);
//			// pretend we had obtained it from the list of os registered editors
//			TableItem ti = new TableItem(editorTable, SWT.NULL);
//			ti.setData(editor);
//			ti.setText(editor.getLabel());
//			Image image = editor.getImageDescriptor().createImage();
//			ti.setImage(image);
//
//			// need to pass an array to setSelection -- 1FSKYVO: SWT:ALL -
//			// inconsistent setSelection api on Table
//			editorTable.setSelection(new TableItem[] { ti });
//			editorTable.showSelection();
//			editorTable.setFocus();
//			selectedEditor = editor;
//
//			/*
//			 * add to our collection of cached external editors in case the user
//			 * flips back and forth between internal/external
//			 */
//			IEditorDescriptor[] newEditors = new IEditorDescriptor[externalEditors.length + 1];
//			System.arraycopy(externalEditors, 0, newEditors, 0,
//					externalEditors.length);
//			newEditors[newEditors.length - 1] = editor;
//			externalEditors = newEditors;
//
//			Image[] newImages = new Image[externalEditorImages.length + 1];
//			System.arraycopy(externalEditorImages, 0, newImages, 0,
//					externalEditorImages.length);
//			newImages[newImages.length - 1] = image;
//			externalEditorImages = newImages;
//		}
//	}

	/**
	 * Handle a double click event on the list
	 */
	protected void handleDoubleClickEvent() {
		buttonPressed(IDialogConstants.OK_ID);
	}

	/**
	 * Use the dialog store to restore widget values to the values that they
	 * held last time this wizard was used to completion
	 */
	protected void restoreWidgetValues() {
// RAP [rh] external editors not supported
//		IDialogSettings settings = getDialogSettings();
//		boolean wasExternal = settings.getBoolean(STORE_ID_INTERNAL_EXTERNAL);
//		internalButton.setSelection(!wasExternal);
//		externalButton.setSelection(wasExternal);
	}

	/**
	 * Since Finish was pressed, write widget values to the dialog store so that
	 * they will persist into the next invocation of this wizard page
	 */
	protected void saveWidgetValues() {
// RAP [rh] external editors not supported
//		IDialogSettings settings = getDialogSettings();
//		// record whether use was viewing internal or external editors
//		settings
//				.put(STORE_ID_INTERNAL_EXTERNAL, !internalButton.getSelection());
	}

	/**
	 * Set the message displayed by this message dialog
	 *
	 * @param aMessage
	 *            the message
	 */
	public void setMessage(String aMessage) {
		message = aMessage;
	}

	/**
	 * Set the editors which will not appear in the dialog.
	 *
	 * @param editors
	 *            an array of editors
	 */
	public void setEditorsToFilter(IEditorDescriptor[] editors) {
		editorsToFilter = editors;
	}

	/**
	 * Update enabled state.
	 */
	protected void updateEnableState() {
// RAP [rh] external editors not supported
//		boolean enableExternal = externalButton.getSelection();
//		browseExternalEditorsButton.setEnabled(enableExternal);
		updateOkButton();
	}

	protected void createButtonsForButtonBar(Composite parent) {
		okButton = createButton(parent, IDialogConstants.OK_ID,
				IDialogConstants.get().OK_LABEL, true);
		createButton(parent, IDialogConstants.CANCEL_ID,
				IDialogConstants.get().CANCEL_LABEL, false);
		// initially there is no selection so OK button should not be enabled
		okButton.setEnabled(false);

	}

	/**
	 * Update the button enablement state.
	 */
	protected void updateOkButton() {
		// Buttons are null during dialog creation
		if (okButton == null) {
			return;
		}
		// If there is no selection, do not enable OK button
		if (editorTable.getSelectionCount() == 0) {
			okButton.setEnabled(false);
			return;
		}
		// At this point, there is a selection
		okButton.setEnabled(selectedEditor != null);
	}

	private class DialogListener implements Listener {

		/*
		 * (non-Javadoc)
		 *
		 * @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event)
		 */
		public void handleEvent(Event event) {
// RAP [rh] Mouse events don't work reliably with Table
//			if (event.type == SWT.MouseDoubleClick) {
//				handleDoubleClickEvent();
//				return;
//			}
// RAP [rh] external editors not supported
//			if (event.widget == externalButton) {
//				fillEditorTable();
//			} else if (event.widget == browseExternalEditorsButton) {
//				promptForExternalEditor();
/*			} else */ if (event.widget == editorTable) {
				if (editorTable.getSelectionIndex() != -1) {
					selectedEditor = (EditorDescriptor) editorTable
							.getSelection()[0].getData();
				} else {
					selectedEditor = null;
					okButton.setEnabled(false);
				}
			}
			updateEnableState();
		}

	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.Dialog#isResizable()
	 * @since 1.4
	 */
	protected boolean isResizable() {
		return true;
	}
}