core/plugins/org.eclipse.dltk.ui/src/org/eclipse/dltk/internal/ui/actions/OpenStorageWithMenu.java - dltk/org.eclipse.dltk.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2017 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
  *
  *******************************************************************************/
 package org.eclipse.dltk.internal.ui.actions;

 import java.util.ArrayList;
 import java.util.Arrays;

 import org.eclipse.core.resources.IStorage;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.dltk.core.IModelElement;
 import org.eclipse.dltk.internal.ui.editor.ExternalStorageEditorInput;
 import org.eclipse.dltk.ui.DLTKUILanguageManager;
 import org.eclipse.dltk.ui.DLTKUIPlugin;
 import org.eclipse.dltk.ui.IDLTKUILanguageToolkit;
 import org.eclipse.jface.action.ContributionItem;
 import org.eclipse.jface.resource.ImageDescriptor;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.graphics.Image;
 import org.eclipse.swt.widgets.Listener;
 import org.eclipse.swt.widgets.Menu;
 import org.eclipse.swt.widgets.MenuItem;
 import org.eclipse.ui.IEditorDescriptor;
 import org.eclipse.ui.IEditorRegistry;
 import org.eclipse.ui.IWorkbenchPage;
 import org.eclipse.ui.PartInitException;
 import org.eclipse.ui.PlatformUI;
 import org.eclipse.ui.editors.text.EditorsUI;

 /**
  * A menu for opening files in the workbench.
  * <p>
  * An <code>OpenWithMenu</code> is used to populate a menu with "Open With"
  * actions. One action is added for each editor which is applicable to the
  * selected file. If the user selects one of these items, the corresponding
  * editor is opened on the file.
  * </p>
  * <p>
  * This class may be instantiated; it is not intended to be subclassed.
  * </p>
  */
 public class OpenStorageWithMenu extends ContributionItem {

 	private IWorkbenchPage page;

 	private IAdaptable storage;

 	private IEditorRegistry registry = PlatformUI.getWorkbench()
 			.getEditorRegistry();

 	/**
 	 * The id of this action.
 	 */
 	public static final String ID = PlatformUI.PLUGIN_ID
 			+ ".OpenStorageWithMenu";//$NON-NLS-1$

 	/**
 	 * Match both the input and id, so that different types of editor can be
 	 * opened on the same input.
 	 */
 	private static final int MATCH_BOTH = IWorkbenchPage.MATCH_INPUT
 			| IWorkbenchPage.MATCH_ID;

 	/**
 	 * Constructs a new instance of <code>OpenWithMenu</code>.
 	 * <p>
 	 * If this method is used be sure to set the selected file by invoking
 	 * <code>setFile</code>. The file input is required when the user selects an
 	 * item in the menu. At that point the menu will attempt to open an editor
 	 * with the file as its input.
 	 * </p>
 	 *
 	 * @param page
 	 *            the page where the editor is opened if an item within the menu
 	 *            is selected
 	 */
 	public OpenStorageWithMenu(IWorkbenchPage page) {
 		this(page, null);
 	}

 	/**
 	 * Constructs a new instance of <code>OpenWithMenu</code>.
 	 *
 	 * @param page
 	 *            the page where the editor is opened if an item within the menu
 	 *            is selected
 	 * @param storage
 	 *            the selected file
 	 */
 	public OpenStorageWithMenu(IWorkbenchPage page, IAdaptable storage) {
 		super(ID);
 		this.page = page;
 		this.storage = storage;
 	}

 	/**
 	 * Returns an image to show for the corresponding editor descriptor.
 	 *
 	 * @param editorDesc
 	 *            the editor descriptor, or null for the system editor
 	 * @return the image or null
 	 */
 	private Image getImage(IEditorDescriptor editorDesc) {
 		ImageDescriptor imageDesc = getImageDescriptor(editorDesc);
 		if (imageDesc == null) {
 			return null;
 		}
 		Image image = OpenModelElementWithMenu.imageCache.get(imageDesc);
 		if (image == null) {
 			image = imageDesc.createImage();
 			OpenModelElementWithMenu.imageCache.put(imageDesc, image);
 		}
 		return image;
 	}

 	/**
 	 * Returns the image descriptor for the given editor descriptor, or null if
 	 * it has no image.
 	 */
 	private ImageDescriptor getImageDescriptor(IEditorDescriptor editorDesc) {
 		ImageDescriptor imageDesc = null;
 		if (editorDesc == null) {
 			imageDesc = registry.getImageDescriptor(getStorage().getName());
 			// TODO: is this case valid, and if so, what are the implications
 			// for content-type editor bindings?
 		} else {
 			imageDesc = editorDesc.getImageDescriptor();
 		}
 		if (imageDesc == null) {
 			if (editorDesc.getId().equals(
 					IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID)) {
 				imageDesc = registry
 						.getSystemExternalEditorImageDescriptor(getStorage()
 								.getName());
 			}
 		}
 		return imageDesc;
 	}

 	/**
 	 * Creates the menu item for the editor descriptor.
 	 *
 	 * @param menu
 	 *            the menu to add the item to
 	 * @param descriptor
 	 *            the editor descriptor, or null for the system editor
 	 * @param preferredEditor
 	 *            the descriptor of the preferred editor, or <code>null</code>
 	 */
 	private void createMenuItem(Menu menu, final IEditorDescriptor descriptor,
 			final IEditorDescriptor preferredEditor) {
 		// XXX: Would be better to use bold here, but SWT does not support it.
 		final MenuItem menuItem = new MenuItem(menu, SWT.RADIO);
 		boolean isPreferred = preferredEditor != null
 				&& descriptor.getId().equals(preferredEditor.getId());
 		menuItem.setSelection(isPreferred);
 		menuItem.setText(descriptor.getLabel());
 		Image image = getImage(descriptor);
 		if (image != null) {
 			menuItem.setImage(image);
 		}
 		Listener listener = event -> {
 			switch (event.type) {
 			case SWT.Selection:
 				if (menuItem.getSelection()) {
 					openEditor(descriptor);
 				}
 				break;
 			}
 		};
 		menuItem.addListener(SWT.Selection, listener);
 	}

 	private IModelElement getModelElement() {
 		if (this.storage instanceof IModelElement) {
 			return (IModelElement) storage;
 		}

 		return null;
 	}

 	IEditorDescriptor getDefaultEditor() {
 		IEditorDescriptor desc = null;
 		IModelElement elem = getModelElement();
 		if (elem != null) {
 			IDLTKUILanguageToolkit toolkit = DLTKUILanguageManager
 					.getLanguageToolkit(elem);
 			String editorId = toolkit.getEditorId(elem);
 			if (editorId != null) {
 				desc = registry.findEditor(editorId);
 			}
 		}
 		if (desc != null)
 			return desc;

 		IStorage storage = getStorage();
 		if (storage != null) {
 			return registry.getDefaultEditor(storage.getName());
 		}

 		return null;
 	}

 	@Override
 	public void fill(Menu menu, int index) {
 		IStorage storage = getStorage();
 		if (storage == null) {
 			return;
 		}

 		IEditorDescriptor defaultEditor = registry
 				.findEditor(EditorsUI.DEFAULT_TEXT_EDITOR_ID); // may be null
 		IEditorDescriptor preferredEditor = getDefaultEditor(); // may be null

 		IEditorDescriptor[] editors = registry.getEditors(storage.getName());
 		Arrays.sort(editors, OpenModelElementWithMenu.comparer);

 		boolean defaultFound = false;

 		// Check that we don't add it twice. This is possible
 		// if the same editor goes to two mappings.
 		ArrayList alreadyMapped = new ArrayList();

 		if (preferredEditor != null) {
 			createMenuItem(menu, preferredEditor, preferredEditor);
 			if (defaultEditor != null
 					&& preferredEditor.getId().equals(defaultEditor.getId())) {
 				defaultFound = true;
 			}
 			alreadyMapped.add(preferredEditor);
 		}

 		for (int i = 0; i < editors.length; i++) {
 			IEditorDescriptor editor = editors[i];
 			if (!alreadyMapped.contains(editor)) {
 				createMenuItem(menu, editor, preferredEditor);
 				if (defaultEditor != null
 						&& editor.getId().equals(defaultEditor.getId())) {
 					defaultFound = true;
 				}
 				alreadyMapped.add(editor);
 			}
 		}

 		// Only add a separator if there is something to separate
 		if (editors.length > 0) {
 			new MenuItem(menu, SWT.SEPARATOR);
 		}

 		// Add default editor. Check it if it is saved as the preference.
 		if (!defaultFound && defaultEditor != null) {
 			createMenuItem(menu, defaultEditor, preferredEditor);
 		}

 		// Add system editor (should never be null)
 		// IEditorDescriptor descriptor = registry
 		// .findEditor(IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID);
 		// createMenuItem(menu, descriptor, preferredEditor);

 		// // Add system in-place editor (can be null)
 		// IEditorDescriptor descriptor = registry
 		// .findEditor(IEditorRegistry.SYSTEM_INPLACE_EDITOR_ID);
 		// if (descriptor != null) {
 		// createMenuItem(menu, descriptor, preferredEditor);
 		// }
 		createDefaultMenuItem(menu, storage);
 	}

 	/**
 	 * Converts the IAdaptable storage to IFile or null.
 	 */
 	private IStorage getStorage() {
 		if (this.storage instanceof IStorage) {
 			return (IStorage) this.storage;
 		}
 		return this.storage.getAdapter(IStorage.class);
 	}

 	/*
 	 * (non-Javadoc) Returns whether this menu is dynamic.
 	 */
 	@Override
 	public boolean isDynamic() {
 		return true;
 	}

 	/**
 	 * Opens the given editor on the selected file.
 	 *
 	 * @param editor
 	 *            the editor descriptor, or null for the system editor
 	 */
 	private void openEditor(IEditorDescriptor editor) {
 		IStorage storage = getStorage();
 		if (storage == null) {
 			return;
 		}
 		try {
 			String editorId = editor == null ? IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID
 					: editor.getId();
 			(page).openEditor(new ExternalStorageEditorInput(storage),
 					editorId, true, MATCH_BOTH);
 			// only remember the default editor if the open succeeds
 			registry.setDefaultEditor(storage.getName(), editorId);
 		} catch (PartInitException e) {
 			DLTKUIPlugin.log(e);
 		}
 	}

 	/**
 	 * Creates the menu item for clearing the current selection.
 	 *
 	 * @param menu
 	 *            the menu to add the item to
 	 * @param storage
 	 *            the file being edited
 	 */
 	private void createDefaultMenuItem(Menu menu, final IStorage storage) {
 		final IEditorDescriptor desc = getDefaultEditor();
 		if (desc == null) {
 			return;
 		}
 		final MenuItem menuItem = new MenuItem(menu, SWT.RADIO);
 		menuItem.setSelection(desc == null);
 		menuItem.setText(ActionMessages.DefaultEditorDescription_name);

 		Listener listener = event -> {
 			switch (event.type) {
 			case SWT.Selection:
 				if (menuItem.getSelection()) {
 					// registry.setDefaultEditor(storage.getName(), null);
 					try {
 						page.openEditor(new ExternalStorageEditorInput(storage),
 								desc.getId(), true, MATCH_BOTH);
 					} catch (PartInitException e) {
 						DLTKUIPlugin.log(e);
 					}
 				}
 				break;
 			}
 		};

 		menuItem.addListener(SWT.Selection, listener);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2017 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
	*
	*******************************************************************************/
	package org.eclipse.dltk.internal.ui.actions;

	import java.util.ArrayList;
	import java.util.Arrays;

	import org.eclipse.core.resources.IStorage;
	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.dltk.core.IModelElement;
	import org.eclipse.dltk.internal.ui.editor.ExternalStorageEditorInput;
	import org.eclipse.dltk.ui.DLTKUILanguageManager;
	import org.eclipse.dltk.ui.DLTKUIPlugin;
	import org.eclipse.dltk.ui.IDLTKUILanguageToolkit;
	import org.eclipse.jface.action.ContributionItem;
	import org.eclipse.jface.resource.ImageDescriptor;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.graphics.Image;
	import org.eclipse.swt.widgets.Listener;
	import org.eclipse.swt.widgets.Menu;
	import org.eclipse.swt.widgets.MenuItem;
	import org.eclipse.ui.IEditorDescriptor;
	import org.eclipse.ui.IEditorRegistry;
	import org.eclipse.ui.IWorkbenchPage;
	import org.eclipse.ui.PartInitException;
	import org.eclipse.ui.PlatformUI;
	import org.eclipse.ui.editors.text.EditorsUI;

	/**
	* A menu for opening files in the workbench.
	* <p>
	* An <code>OpenWithMenu</code> is used to populate a menu with "Open With"
	* actions. One action is added for each editor which is applicable to the
	* selected file. If the user selects one of these items, the corresponding
	* editor is opened on the file.
	* </p>
	* <p>
	* This class may be instantiated; it is not intended to be subclassed.
	* </p>
	*/
	public class OpenStorageWithMenu extends ContributionItem {

	private IWorkbenchPage page;

	private IAdaptable storage;

	private IEditorRegistry registry = PlatformUI.getWorkbench()
	.getEditorRegistry();

	/**
	* The id of this action.
	*/
	public static final String ID = PlatformUI.PLUGIN_ID
	+ ".OpenStorageWithMenu";//$NON-NLS-1$

	/**
	* Match both the input and id, so that different types of editor can be
	* opened on the same input.
	*/
	private static final int MATCH_BOTH = IWorkbenchPage.MATCH_INPUT
	\| IWorkbenchPage.MATCH_ID;

	/**
	* Constructs a new instance of <code>OpenWithMenu</code>.
	* <p>
	* If this method is used be sure to set the selected file by invoking
	* <code>setFile</code>. The file input is required when the user selects an
	* item in the menu. At that point the menu will attempt to open an editor
	* with the file as its input.
	* </p>
	*
	* @param page
	* the page where the editor is opened if an item within the menu
	* is selected
	*/
	public OpenStorageWithMenu(IWorkbenchPage page) {
	this(page, null);
	}

	/**
	* Constructs a new instance of <code>OpenWithMenu</code>.
	*
	* @param page
	* the page where the editor is opened if an item within the menu
	* is selected
	* @param storage
	* the selected file
	*/
	public OpenStorageWithMenu(IWorkbenchPage page, IAdaptable storage) {
	super(ID);
	this.page = page;
	this.storage = storage;
	}

	/**
	* Returns an image to show for the corresponding editor descriptor.
	*
	* @param editorDesc
	* the editor descriptor, or null for the system editor
	* @return the image or null
	*/
	private Image getImage(IEditorDescriptor editorDesc) {
	ImageDescriptor imageDesc = getImageDescriptor(editorDesc);
	if (imageDesc == null) {
	return null;
	}
	Image image = OpenModelElementWithMenu.imageCache.get(imageDesc);
	if (image == null) {
	image = imageDesc.createImage();
	OpenModelElementWithMenu.imageCache.put(imageDesc, image);
	}
	return image;
	}

	/**
	* Returns the image descriptor for the given editor descriptor, or null if
	* it has no image.
	*/
	private ImageDescriptor getImageDescriptor(IEditorDescriptor editorDesc) {
	ImageDescriptor imageDesc = null;
	if (editorDesc == null) {
	imageDesc = registry.getImageDescriptor(getStorage().getName());
	// TODO: is this case valid, and if so, what are the implications
	// for content-type editor bindings?
	} else {
	imageDesc = editorDesc.getImageDescriptor();
	}
	if (imageDesc == null) {
	if (editorDesc.getId().equals(
	IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID)) {
	imageDesc = registry
	.getSystemExternalEditorImageDescriptor(getStorage()
	.getName());
	}
	}
	return imageDesc;
	}

	/**
	* Creates the menu item for the editor descriptor.
	*
	* @param menu
	* the menu to add the item to
	* @param descriptor
	* the editor descriptor, or null for the system editor
	* @param preferredEditor
	* the descriptor of the preferred editor, or <code>null</code>
	*/
	private void createMenuItem(Menu menu, final IEditorDescriptor descriptor,
	final IEditorDescriptor preferredEditor) {
	// XXX: Would be better to use bold here, but SWT does not support it.
	final MenuItem menuItem = new MenuItem(menu, SWT.RADIO);
	boolean isPreferred = preferredEditor != null
	&& descriptor.getId().equals(preferredEditor.getId());
	menuItem.setSelection(isPreferred);
	menuItem.setText(descriptor.getLabel());
	Image image = getImage(descriptor);
	if (image != null) {
	menuItem.setImage(image);
	}
	Listener listener = event -> {
	switch (event.type) {
	case SWT.Selection:
	if (menuItem.getSelection()) {
	openEditor(descriptor);
	}
	break;
	}
	};
	menuItem.addListener(SWT.Selection, listener);
	}

	private IModelElement getModelElement() {
	if (this.storage instanceof IModelElement) {
	return (IModelElement) storage;
	}

	return null;
	}

	IEditorDescriptor getDefaultEditor() {
	IEditorDescriptor desc = null;
	IModelElement elem = getModelElement();
	if (elem != null) {
	IDLTKUILanguageToolkit toolkit = DLTKUILanguageManager
	.getLanguageToolkit(elem);
	String editorId = toolkit.getEditorId(elem);
	if (editorId != null) {
	desc = registry.findEditor(editorId);
	}
	}
	if (desc != null)
	return desc;

	IStorage storage = getStorage();
	if (storage != null) {
	return registry.getDefaultEditor(storage.getName());
	}

	return null;
	}

	@Override
	public void fill(Menu menu, int index) {
	IStorage storage = getStorage();
	if (storage == null) {
	return;
	}

	IEditorDescriptor defaultEditor = registry
	.findEditor(EditorsUI.DEFAULT_TEXT_EDITOR_ID); // may be null
	IEditorDescriptor preferredEditor = getDefaultEditor(); // may be null

	IEditorDescriptor[] editors = registry.getEditors(storage.getName());
	Arrays.sort(editors, OpenModelElementWithMenu.comparer);

	boolean defaultFound = false;

	// Check that we don't add it twice. This is possible
	// if the same editor goes to two mappings.
	ArrayList alreadyMapped = new ArrayList();

	if (preferredEditor != null) {
	createMenuItem(menu, preferredEditor, preferredEditor);
	if (defaultEditor != null
	&& preferredEditor.getId().equals(defaultEditor.getId())) {
	defaultFound = true;
	}
	alreadyMapped.add(preferredEditor);
	}

	for (int i = 0; i < editors.length; i++) {
	IEditorDescriptor editor = editors[i];
	if (!alreadyMapped.contains(editor)) {
	createMenuItem(menu, editor, preferredEditor);
	if (defaultEditor != null
	&& editor.getId().equals(defaultEditor.getId())) {
	defaultFound = true;
	}
	alreadyMapped.add(editor);
	}
	}

	// Only add a separator if there is something to separate
	if (editors.length > 0) {
	new MenuItem(menu, SWT.SEPARATOR);
	}

	// Add default editor. Check it if it is saved as the preference.
	if (!defaultFound && defaultEditor != null) {
	createMenuItem(menu, defaultEditor, preferredEditor);
	}

	// Add system editor (should never be null)
	// IEditorDescriptor descriptor = registry
	// .findEditor(IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID);
	// createMenuItem(menu, descriptor, preferredEditor);

	// // Add system in-place editor (can be null)
	// IEditorDescriptor descriptor = registry
	// .findEditor(IEditorRegistry.SYSTEM_INPLACE_EDITOR_ID);
	// if (descriptor != null) {
	// createMenuItem(menu, descriptor, preferredEditor);
	// }
	createDefaultMenuItem(menu, storage);
	}

	/**
	* Converts the IAdaptable storage to IFile or null.
	*/
	private IStorage getStorage() {
	if (this.storage instanceof IStorage) {
	return (IStorage) this.storage;
	}
	return this.storage.getAdapter(IStorage.class);
	}

	/*
	* (non-Javadoc) Returns whether this menu is dynamic.
	*/
	@Override
	public boolean isDynamic() {
	return true;
	}

	/**
	* Opens the given editor on the selected file.
	*
	* @param editor
	* the editor descriptor, or null for the system editor
	*/
	private void openEditor(IEditorDescriptor editor) {
	IStorage storage = getStorage();
	if (storage == null) {
	return;
	}
	try {
	String editorId = editor == null ? IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID
	: editor.getId();
	(page).openEditor(new ExternalStorageEditorInput(storage),
	editorId, true, MATCH_BOTH);
	// only remember the default editor if the open succeeds
	registry.setDefaultEditor(storage.getName(), editorId);
	} catch (PartInitException e) {
	DLTKUIPlugin.log(e);
	}
	}

	/**
	* Creates the menu item for clearing the current selection.
	*
	* @param menu
	* the menu to add the item to
	* @param storage
	* the file being edited
	*/
	private void createDefaultMenuItem(Menu menu, final IStorage storage) {
	final IEditorDescriptor desc = getDefaultEditor();
	if (desc == null) {
	return;
	}
	final MenuItem menuItem = new MenuItem(menu, SWT.RADIO);
	menuItem.setSelection(desc == null);
	menuItem.setText(ActionMessages.DefaultEditorDescription_name);

	Listener listener = event -> {
	switch (event.type) {
	case SWT.Selection:
	if (menuItem.getSelection()) {
	// registry.setDefaultEditor(storage.getName(), null);
	try {
	page.openEditor(new ExternalStorageEditorInput(storage),
	desc.getId(), true, MATCH_BOTH);
	} catch (PartInitException e) {
	DLTKUIPlugin.log(e);
	}
	}
	break;
	}
	};

	menuItem.addListener(SWT.Selection, listener);
	}
	}