/*******************************************************************************
* 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();
}
}
}
}