| /******************************************************************************* |
| * Copyright (c) 2004, 2006 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.wst.sse.ui.tests; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.nio.ByteBuffer; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Vector; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IStorage; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.content.IContentType; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.jface.dialogs.ErrorDialog; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.viewers.ArrayContentProvider; |
| import org.eclipse.jface.viewers.CellEditor; |
| import org.eclipse.jface.viewers.ColumnWeightData; |
| import org.eclipse.jface.viewers.DoubleClickEvent; |
| import org.eclipse.jface.viewers.IDoubleClickListener; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.jface.viewers.ILabelProviderListener; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.ITableLabelProvider; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.TableLayout; |
| import org.eclipse.jface.viewers.TableViewer; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.FileDialog; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.TableColumn; |
| import org.eclipse.ui.IEditorDescriptor; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorRegistry; |
| import org.eclipse.ui.IFileEditorInput; |
| import org.eclipse.ui.IPersistableElement; |
| import org.eclipse.ui.IReusableEditor; |
| import org.eclipse.ui.IStorageEditorInput; |
| import org.eclipse.ui.IViewSite; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.actions.OpenWithMenu; |
| import org.eclipse.ui.dialogs.ResourceSelectionDialog; |
| import org.eclipse.ui.editors.text.EditorsUI; |
| import org.eclipse.ui.model.WorkbenchLabelProvider; |
| import org.eclipse.ui.part.FileEditorInput; |
| import org.eclipse.ui.part.ViewPart; |
| import org.eclipse.ui.texteditor.IElementStateListener; |
| import org.eclipse.ui.texteditor.IUpdate; |
| import org.eclipse.wst.sse.core.utils.StringUtils; |
| import org.eclipse.wst.sse.ui.internal.SSEUIPlugin; |
| import org.eclipse.wst.sse.ui.internal.provisional.extensions.breakpoint.IExtendedStorageEditorInput; |
| |
| |
| /** |
| * @author nitin |
| * |
| * A view to assist in testing out StructuredTextEditor's IEditorInput |
| * handling. |
| * |
| * Permanently in-progress. |
| */ |
| public class ExtendedStorageEditorInputView extends ViewPart { |
| /** |
| * Adds an IFileEditorInput to the list of inputs with which to test |
| */ |
| class AddFileInputAction extends Action { |
| public AddFileInputAction() { |
| super("Add FileEditorInput"); |
| } |
| |
| public void run() { |
| super.run(); |
| ResourceSelectionDialog dlg = new ResourceSelectionDialog(fInputList.getControl().getShell(), ResourcesPlugin.getWorkspace().getRoot(), "Choose"); |
| int retval = dlg.open(); |
| if (retval == Window.OK) { |
| Object[] files = dlg.getResult(); |
| for (int i = 0; i < files.length; i++) { |
| fInputs.add(new FileEditorInput((IFile) files[i])); |
| } |
| fInputList.refresh(true); |
| } |
| } |
| } |
| |
| /** |
| * Adds an IStorageEditorInput to the list of inputs with which to test |
| */ |
| class AddStorageInputAction extends Action { |
| public AddStorageInputAction() { |
| super("Add StorageEditorInput"); |
| } |
| |
| public void run() { |
| super.run(); |
| FileDialog dlg = new FileDialog(fInputList.getControl().getShell()); |
| String fileName = dlg.open(); |
| if (fileName != null) { |
| fInputs.add(new FileBasedStorageEditorInput(new File(fileName))); |
| fInputList.refresh(true); |
| } |
| } |
| } |
| |
| /** |
| * Handler for double-click |
| */ |
| class DoubleClickListener implements IDoubleClickListener { |
| public void doubleClick(DoubleClickEvent event) { |
| new InputOpenAction().run(); |
| } |
| } |
| |
| class EditorInputLabelProvider implements ITableLabelProvider { |
| ILabelProvider baseProvider = new WorkbenchLabelProvider(); |
| |
| public void addListener(ILabelProviderListener listener) { |
| // not implemented |
| } |
| |
| public void dispose() { |
| // no need |
| } |
| |
| public Image getColumnImage(Object element, int columnIndex) { |
| if (element instanceof IFileEditorInput && columnIndex == 0) { |
| return baseProvider.getImage(((IFileEditorInput) element).getFile()); |
| } |
| return null; |
| } |
| |
| public String getColumnText(Object element, int columnIndex) { |
| IEditorInput input = (IEditorInput) element; |
| String text = null; |
| switch (columnIndex) { |
| case 0 : |
| try { |
| if (element instanceof FileBasedStorageEditorInput) { |
| IPath fullpath = ((FileBasedStorageEditorInput) element).getStorage().getFullPath(); |
| text = fullpath != null ? fullpath.toString() : ((FileBasedStorageEditorInput) element).getName(); |
| if (((FileBasedStorageEditorInput) element).isDirty()) { |
| text = "*" + text; |
| } |
| } |
| else if (element instanceof IFileEditorInput) { |
| text = ((IFileEditorInput) element).getFile().getFullPath().toString(); |
| } |
| } |
| catch (CoreException e) { |
| e.printStackTrace(); |
| } |
| |
| break; |
| case 1 : |
| if (element instanceof FileBasedStorageEditorInput) { |
| text = "FileBasedStorageEditorInput"; |
| } |
| else if (element instanceof IFileEditorInput) { |
| text = "FileEditorInput"; |
| } |
| else { |
| text = input.getClass().getName(); |
| } |
| break; |
| } |
| if (text == null) |
| text = ""; |
| return text; |
| } |
| |
| public boolean isLabelProperty(Object element, String property) { |
| return false; |
| } |
| |
| public void removeListener(ILabelProviderListener listener) { |
| // not implemented |
| } |
| } |
| |
| |
| class FileBackedStorage implements IStorage { |
| File fFile = null; |
| |
| FileBackedStorage(File file) { |
| super(); |
| fFile = file; |
| } |
| |
| boolean exists() { |
| return fFile.exists(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class) |
| */ |
| public Object getAdapter(Class adapter) { |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.core.resources.IStorage#getContents() |
| */ |
| public InputStream getContents() throws CoreException { |
| InputStream contents = null; |
| try { |
| contents = new FileInputStream(fFile); |
| ByteBuffer buffer = ByteBuffer.allocate((int) fFile.length()); |
| byte[] bytes = new byte[2048]; |
| while (contents.available() > 0) { |
| int count = contents.read(bytes); |
| buffer.put(bytes, 0, count); |
| } |
| contents.close(); |
| |
| contents = new ByteArrayInputStream(buffer.array()); |
| } |
| catch (FileNotFoundException e) { |
| contents = new ByteArrayInputStream(new byte[0]); |
| } |
| catch (IOException e) { |
| contents = new ByteArrayInputStream(new byte[0]); |
| } |
| return contents; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.core.resources.IStorage#getFullPath() |
| */ |
| public IPath getFullPath() { |
| if (provideIStorageFullPath) { |
| return new Path(fFile.getAbsolutePath()); |
| } |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.core.resources.IStorage#getName() |
| */ |
| public String getName() { |
| return fFile.getName(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.core.resources.IStorage#isReadOnly() |
| */ |
| public boolean isReadOnly() { |
| return true; |
| } |
| } |
| |
| class FileBasedStorageEditorInput implements IExtendedStorageEditorInput { |
| List fElementStateListeners = new Vector(0); |
| boolean fIsDirty = false; |
| FileBackedStorage fStorage = null; |
| |
| FileBasedStorageEditorInput(File file) { |
| fStorage = new FileBackedStorage(file); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.wst.sse.ui.extensions.breakpoint.IExtendedStorageEditorInput#addElementStateListener(org.eclipse.ui.texteditor.IElementStateListener) |
| */ |
| public void addElementStateListener(IElementStateListener listener) { |
| fElementStateListeners.add(listener); |
| } |
| |
| void elementContentAboutToBeReplaced() { |
| for (int i = 0; i < fElementStateListeners.size(); i++) { |
| ((IElementStateListener) fElementStateListeners.get(i)).elementContentAboutToBeReplaced(FileBasedStorageEditorInput.this); |
| } |
| } |
| |
| void elementContentReplaced() { |
| for (int i = 0; i < fElementStateListeners.size(); i++) { |
| ((IElementStateListener) fElementStateListeners.get(i)).elementContentReplaced(FileBasedStorageEditorInput.this); |
| } |
| } |
| |
| void elementDeleted() { |
| for (int i = 0; i < fElementStateListeners.size(); i++) { |
| ((IElementStateListener) fElementStateListeners.get(i)).elementDeleted(FileBasedStorageEditorInput.this); |
| } |
| } |
| |
| void elementDirtyStateChanged(boolean dirty) { |
| setDirty(dirty); |
| for (int i = 0; i < fElementStateListeners.size(); i++) { |
| ((IElementStateListener) fElementStateListeners.get(i)).elementDirtyStateChanged(FileBasedStorageEditorInput.this, dirty); |
| } |
| } |
| |
| void elementMoved(Object oldElement, Object newElement) { |
| for (int i = 0; i < fElementStateListeners.size(); i++) { |
| ((IElementStateListener) fElementStateListeners.get(i)).elementMoved(FileBasedStorageEditorInput.this, FileBasedStorageEditorInput.this); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.IEditorInput#exists() |
| */ |
| public boolean exists() { |
| return fStorage.exists(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class) |
| */ |
| public Object getAdapter(Class adapter) { |
| return null; |
| } |
| |
| File getFile() { |
| return fStorage.fFile; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.IEditorInput#getImageDescriptor() |
| */ |
| public ImageDescriptor getImageDescriptor() { |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.IEditorInput#getName() |
| */ |
| public String getName() { |
| return fStorage.getName(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.IEditorInput#getPersistable() |
| */ |
| public IPersistableElement getPersistable() { |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.IStorageEditorInput#getStorage() |
| */ |
| public IStorage getStorage() throws CoreException { |
| return fStorage; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.IEditorInput#getToolTipText() |
| */ |
| public String getToolTipText() { |
| return fStorage.getFullPath() != null ? fStorage.getFullPath().toString() : fStorage.getName(); |
| } |
| |
| boolean isDirty() { |
| return fIsDirty; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.wst.sse.ui.extensions.breakpoint.IExtendedStorageEditorInput#removeElementStateListener(org.eclipse.ui.texteditor.IElementStateListener) |
| */ |
| public void removeElementStateListener(IElementStateListener listener) { |
| fElementStateListeners.remove(listener); |
| } |
| |
| void setDirty(boolean dirty) { |
| fIsDirty = dirty; |
| } |
| } |
| |
| class InputChangeDirtyStateAction extends Action implements IUpdate { |
| public InputChangeDirtyStateAction() { |
| super("Toggle dirty flag"); |
| } |
| |
| public void run() { |
| super.run(); |
| IEditorInput[] inputs = getSelectedInputs(); |
| for (int i = 0; i < inputs.length; i++) { |
| if (inputs[i] instanceof FileBasedStorageEditorInput) { |
| ((FileBasedStorageEditorInput) inputs[i]).elementDirtyStateChanged(!((FileBasedStorageEditorInput) inputs[i]).isDirty()); |
| } |
| } |
| fInputList.refresh(true); |
| } |
| |
| public void update() { |
| setEnabled(fSelectedElement != null && fSelectedElement instanceof FileBasedStorageEditorInput); |
| } |
| } |
| |
| class InputDeleteAction extends Action implements IUpdate { |
| public InputDeleteAction() { |
| super("Delete Input"); |
| } |
| |
| public void run() { |
| super.run(); |
| IEditorInput[] inputs = getSelectedInputs(); |
| for (int i = 0; i < inputs.length; i++) { |
| if (inputs[i] instanceof FileBasedStorageEditorInput) { |
| ((FileBasedStorageEditorInput) inputs[i]).elementDeleted(); |
| } |
| } |
| for (int i = 0; i < inputs.length; i++) { |
| fInputs.remove(inputs[i]); |
| } |
| fInputList.refresh(); |
| } |
| |
| public void update() { |
| setEnabled(fSelectedElement != null && fSelectedElement instanceof FileBasedStorageEditorInput); |
| } |
| } |
| |
| class InputMoveAction extends Action implements IUpdate { |
| public InputMoveAction() { |
| super("Move Input"); |
| } |
| |
| public void run() { |
| super.run(); |
| IEditorInput[] inputs = getSelectedInputs(); |
| for (int i = 0; i < inputs.length; i++) { |
| if (inputs[i] instanceof FileBasedStorageEditorInput) { |
| ((FileBasedStorageEditorInput) inputs[i]).elementMoved(inputs[i], inputs[i]); |
| } |
| } |
| } |
| |
| public void update() { |
| setEnabled(fSelectedElement != null && fSelectedElement instanceof FileBasedStorageEditorInput); |
| } |
| } |
| |
| class InputOpenAction extends Action { |
| public InputOpenAction() { |
| super("Open"); |
| } |
| |
| public void run() { |
| super.run(); |
| IEditorInput[] inputs = getSelectedInputs(); |
| for (int i = 0; i < inputs.length; i++) { |
| try { |
| getSite().getWorkbenchWindow().getActivePage().openEditor(inputs[i], getEditorId(inputs[i])); |
| } |
| catch (PartInitException e) { |
| openError(getSite().getWorkbenchWindow().getActivePage().getWorkbenchWindow().getShell(), "OpenSystemEditorAction.dialogTitle", e.getMessage(), e); |
| } |
| } |
| } |
| } |
| |
| class InputReplaceContentsAction extends Action implements IUpdate { |
| public InputReplaceContentsAction() { |
| super("Replace Input's Contents"); |
| } |
| |
| public void run() { |
| super.run(); |
| IEditorInput[] inputs = getSelectedInputs(); |
| for (int i = 0; i < inputs.length; i++) { |
| ((FileBasedStorageEditorInput) inputs[i]).elementContentAboutToBeReplaced(); |
| ((FileBasedStorageEditorInput) inputs[i]).elementContentReplaced(); |
| } |
| } |
| |
| public void update() { |
| setEnabled(fSelectedElement != null && fSelectedElement instanceof FileBasedStorageEditorInput); |
| } |
| } |
| |
| class RemoveInputAction extends Action { |
| public RemoveInputAction() { |
| super("Remove"); |
| } |
| |
| public void run() { |
| super.run(); |
| IEditorInput[] inputs = getSelectedInputs(); |
| for (int i = 0; i < inputs.length; i++) { |
| fInputs.remove(inputs[i]); |
| } |
| fInputList.refresh(); |
| } |
| } |
| |
| class ReuseEditorAction extends Action implements IUpdate { |
| public ReuseEditorAction() { |
| super("Reuse Editor"); |
| } |
| |
| public void run() { |
| super.run(); |
| IEditorInput[] inputs = getSelectedInputs(); |
| for (int i = 0; i < inputs.length; i++) { |
| IEditorPart editor = getSite().getWorkbenchWindow().getActivePage().getActiveEditor(); |
| if (editor instanceof IReusableEditor) { |
| getSite().getWorkbenchWindow().getActivePage().reuseEditor(((IReusableEditor) editor), inputs[i]); |
| } |
| else { |
| SSEUIPlugin.getDefault().getWorkbench().getDisplay().beep(); |
| } |
| } |
| } |
| |
| public void update() { |
| boolean enable = true; |
| try { |
| enable = fSelectedElement != null && getSite().getWorkbenchWindow().getActivePage().getActiveEditor() instanceof IReusableEditor; |
| } |
| catch (Exception e) { |
| enable = true; |
| } |
| setEnabled(enable); |
| } |
| } |
| |
| |
| public static final boolean provideIStorageFullPath = true; |
| |
| /** |
| * Open an error style dialog for PartInitException by including any extra |
| * information from the nested CoreException if present. |
| */ |
| public static void openError(Shell parent, String title, String message, PartInitException exception) { |
| // Check for a nested CoreException |
| CoreException nestedException = null; |
| IStatus status = exception.getStatus(); |
| if (status != null && status.getException() instanceof CoreException) |
| nestedException = (CoreException) status.getException(); |
| |
| if (nestedException != null) { |
| // Open an error dialog and include the extra |
| // status information from the nested CoreException |
| ErrorDialog.openError(parent, title, message, nestedException.getStatus()); |
| } |
| else { |
| // Open a regular error dialog since there is no |
| // extra information to display |
| MessageDialog.openError(parent, title, message); |
| } |
| } |
| |
| private List actions = null; |
| |
| TableViewer fInputList = null; |
| |
| List fInputs = new ArrayList(0); |
| |
| Object fSelectedElement = null; |
| |
| |
| public ExtendedStorageEditorInputView() { |
| super(); |
| actions = new ArrayList(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.IWorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite) |
| */ |
| public void createPartControl(Composite parent) { |
| fInputList = new TableViewer(parent, SWT.FULL_SELECTION | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL); |
| fInputList.setContentProvider(new ArrayContentProvider()); |
| fInputList.setLabelProvider(new EditorInputLabelProvider()); |
| fInputList.addDoubleClickListener(new DoubleClickListener()); |
| fInputList.getTable().setHeaderVisible(true); |
| fInputList.getTable().setLinesVisible(true); |
| String[] columns = new String[]{"Path", "Type"}; |
| fInputList.setLabelProvider(new EditorInputLabelProvider()); |
| |
| |
| TableLayout tlayout = new TableLayout(); |
| CellEditor[] cellEditors = new CellEditor[5]; |
| for (int i = 0; i < columns.length; i++) { |
| tlayout.addColumnData(new ColumnWeightData(1)); |
| TableColumn tc = new TableColumn(fInputList.getTable(), SWT.NONE); |
| tc.setText(columns[i]); |
| tc.setResizable(true); |
| tc.setWidth(Display.getCurrent().getBounds().width / 14); |
| } |
| fInputList.setCellEditors(cellEditors); |
| fInputList.setColumnProperties(columns); |
| |
| GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true); |
| fInputList.getTable().setLayoutData(gd); |
| |
| MenuManager menuManager = new MenuManager("#popup"); //$NON-NLS-1$ |
| menuManager.setRemoveAllWhenShown(false); |
| |
| menuManager.add(new InputOpenAction()); |
| menuManager.add(new Separator()); |
| menuManager.add(new InputMoveAction()); |
| menuManager.add(new InputChangeDirtyStateAction()); |
| menuManager.add(new InputDeleteAction()); |
| menuManager.add(new InputReplaceContentsAction()); |
| menuManager.add(new Separator()); |
| menuManager.add(new RemoveInputAction()); |
| Menu menu = menuManager.createContextMenu(fInputList.getControl()); |
| fInputList.getControl().setMenu(menu); |
| |
| |
| SSETestsPlugin.getDefault().getPluginPreferences().setDefault(getInputsPreferenceName(), ""); |
| String paths[] = StringUtils.unpack(SSETestsPlugin.getDefault().getPluginPreferences().getString(getInputsPreferenceName())); |
| for (int i = 0; i < paths.length; i++) { |
| if (paths[i].startsWith("S!")) { |
| fInputs.add(new FileBasedStorageEditorInput(new File(paths[i].substring(2)))); |
| menuManager.add(new OpenWithMenu(getSite().getPage(), null)); |
| } |
| else if (paths[i].startsWith("F!")) { |
| IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(paths[i].substring(2))); |
| fInputs.add(new FileEditorInput(file)); |
| menuManager.add(new OpenWithMenu(getSite().getPage(), file)); |
| } |
| } |
| |
| fInputList.setInput(fInputs); |
| fInputList.addSelectionChangedListener(new ISelectionChangedListener() { |
| public void selectionChanged(SelectionChangedEvent event) { |
| IStructuredSelection sel = ((IStructuredSelection) event.getSelection()); |
| fSelectedElement = sel.getFirstElement(); |
| } |
| }); |
| } |
| |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.IWorkbenchPart#dispose() |
| */ |
| public void dispose() { |
| List paths = new ArrayList(0); |
| for (int i = 0; i < fInputs.size(); i++) { |
| try { |
| Object input = fInputs.get(i); |
| String path = null; |
| if (input instanceof FileBasedStorageEditorInput) { |
| path = "S!" + ((FileBasedStorageEditorInput) input).getFile().getCanonicalPath(); |
| } |
| else if (input instanceof IFileEditorInput) { |
| path = "F!" + ((IFileEditorInput) input).getFile().getFullPath().toString(); |
| } |
| if (path != null) { |
| paths.add(path); |
| } |
| } |
| catch (IOException e) { |
| e.printStackTrace(); |
| } |
| } |
| SSETestsPlugin.getDefault().getPluginPreferences().setValue(getInputsPreferenceName(), StringUtils.pack((String[]) paths.toArray(new String[0]))); |
| SSETestsPlugin.getDefault().savePluginPreferences(); |
| } |
| |
| String getEditorId(IEditorInput input) { |
| IWorkbench workbench = PlatformUI.getWorkbench(); |
| IEditorRegistry editorRegistry = workbench.getEditorRegistry(); |
| IContentType[] types = null; |
| String editorID = null; |
| if (input instanceof IStorageEditorInput) { |
| InputStream inputStream = null; |
| try { |
| inputStream = ((IStorageEditorInput) input).getStorage().getContents(); |
| } |
| catch (CoreException e) { |
| e.printStackTrace(); |
| } |
| try { |
| types = Platform.getContentTypeManager().findContentTypesFor(inputStream, input.getName()); |
| } |
| catch (IOException e) { |
| e.printStackTrace(); |
| } |
| try { |
| if (inputStream != null) { |
| inputStream.close(); |
| } |
| } |
| catch (IOException e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| IEditorDescriptor descriptor = editorRegistry.getDefaultEditor(input.getName(), types[0]); |
| if (descriptor != null) { |
| editorID = descriptor.getId(); |
| } |
| if (editorID == null) { |
| editorID = EditorsUI.DEFAULT_TEXT_EDITOR_ID; |
| } |
| return editorID; |
| } |
| |
| /** |
| * @return |
| */ |
| String getInputsPreferenceName() { |
| return "ExtendedStorageEditorInputView:inputs"; |
| } |
| |
| IEditorInput[] getSelectedInputs() { |
| ISelection selection = fInputList.getSelection(); |
| if (selection instanceof IStructuredSelection) { |
| IStructuredSelection sel = (IStructuredSelection) selection; |
| if (sel.isEmpty()) { |
| return new IEditorInput[0]; |
| } |
| Object[] arr = sel.toArray(); |
| IEditorInput[] inputs = new IEditorInput[arr.length]; |
| System.arraycopy(arr, 0, inputs, 0, inputs.length); |
| return inputs; |
| } |
| return new IEditorInput[0]; |
| } |
| |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.IViewPart#init(org.eclipse.ui.IViewSite) |
| */ |
| public void init(IViewSite site) throws PartInitException { |
| super.init(site); |
| |
| site.getActionBars().getToolBarManager().add(rememberAction(new AddStorageInputAction())); |
| site.getActionBars().getToolBarManager().add(rememberAction(new AddFileInputAction())); |
| site.getActionBars().getToolBarManager().add(rememberAction(new ReuseEditorAction())); |
| site.getActionBars().getToolBarManager().add(rememberAction(new RemoveInputAction())); |
| |
| site.getActionBars().getMenuManager().add(rememberAction(new InputOpenAction())); |
| site.getActionBars().getMenuManager().add(rememberAction(new ReuseEditorAction())); |
| site.getActionBars().getMenuManager().add(new Separator()); |
| site.getActionBars().getMenuManager().add(rememberAction(new InputMoveAction())); |
| site.getActionBars().getMenuManager().add(rememberAction(new InputChangeDirtyStateAction())); |
| site.getActionBars().getMenuManager().add(rememberAction(new InputDeleteAction())); |
| site.getActionBars().getMenuManager().add(rememberAction(new InputReplaceContentsAction())); |
| } |
| |
| IAction rememberAction(IAction action) { |
| actions.add(action); |
| return action; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.IWorkbenchPart#setFocus() |
| */ |
| public void setFocus() { |
| fInputList.getControl().setFocus(); |
| } |
| |
| |
| protected void updateEnablement() { |
| for (int i = 0; i < actions.size(); i++) { |
| Object action = actions.get(i); |
| if (action instanceof IUpdate) { |
| ((IUpdate) action).update(); |
| } |
| } |
| } |
| } |