| /******************************************************************************* |
| * Copyright (c) 2000, 2003 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Common Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/cpl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.ui.internal.editorsupport.win32; |
| |
| import java.io.File; |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.Vector; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IResourceChangeEvent; |
| import org.eclipse.core.resources.IResourceChangeListener; |
| import org.eclipse.core.resources.IResourceDelta; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.BusyIndicator; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.ole.win32.OLE; |
| import org.eclipse.swt.ole.win32.OleAutomation; |
| import org.eclipse.swt.ole.win32.OleClientSite; |
| import org.eclipse.swt.ole.win32.OleFrame; |
| import org.eclipse.swt.ole.win32.Variant; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.MenuItem; |
| import org.eclipse.swt.widgets.Shell; |
| |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.dialogs.ProgressMonitorDialog; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.resource.JFaceColors; |
| |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorSite; |
| import org.eclipse.ui.IFileEditorInput; |
| import org.eclipse.ui.IPartListener; |
| import org.eclipse.ui.IWorkbench; |
| import org.eclipse.ui.IWorkbenchActionConstants; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.actions.WorkspaceModifyOperation; |
| import org.eclipse.ui.dialogs.SaveAsDialog; |
| import org.eclipse.ui.internal.WorkbenchMessages; |
| import org.eclipse.ui.part.EditorPart; |
| import org.eclipse.ui.part.FileEditorInput; |
| |
| /** |
| */ |
| public class OleEditor extends EditorPart { |
| |
| /** |
| * The resource listener updates the receiver when |
| * a change has occured. |
| */ |
| private IResourceChangeListener resourceListener = |
| new IResourceChangeListener() { |
| |
| /* |
| * @see IResourceChangeListener#resourceChanged(IResourceChangeEvent) |
| */ |
| public void resourceChanged(IResourceChangeEvent event) { |
| IResourceDelta mainDelta = event.getDelta(); |
| if(mainDelta == null) |
| return; |
| IResourceDelta affectedElement = |
| mainDelta.findMember(resource.getFullPath()); |
| if (affectedElement != null) |
| try { |
| processDelta(affectedElement); |
| } catch (CoreException exception) { |
| //Failed so close the receiver |
| getSite().getPage().closeEditor(OleEditor.this, true); |
| } |
| } |
| |
| /* |
| * Process the delta for the receiver |
| */ |
| private boolean processDelta(final IResourceDelta delta) throws CoreException { |
| |
| Runnable changeRunnable = null; |
| |
| switch (delta.getKind()) { |
| case IResourceDelta.REMOVED : |
| if ((IResourceDelta.MOVED_TO & delta.getFlags()) != 0) { |
| changeRunnable = new Runnable() { |
| public void run() { |
| IPath path = delta.getMovedToPath(); |
| IFile newFile = delta.getResource().getWorkspace().getRoot().getFile(path); |
| if (newFile != null) { |
| sourceChanged(newFile); |
| } |
| } |
| }; |
| } else { |
| changeRunnable = new Runnable() { |
| public void run() { |
| sourceDeleted = true; |
| getSite().getPage().closeEditor(OleEditor.this, true); |
| } |
| }; |
| |
| } |
| |
| break; |
| } |
| |
| if (changeRunnable != null) |
| update(changeRunnable); |
| |
| return true; // because we are sitting on files anyway |
| } |
| |
| }; |
| |
| private OleFrame clientFrame; |
| private OleClientSite clientSite; |
| private File source; |
| private IFile resource; |
| private Image oleTitleImage; |
| //The sourceDeleted flag makes sure that the receiver is not |
| //dirty when shutting down |
| boolean sourceDeleted = false; |
| //The sourceChanged flag indicates whether or not the save from the ole component |
| //can be used or if the input changed |
| boolean sourceChanged = false; |
| |
| /** |
| * Keep track of whether we have an active client so we do not |
| * deactivate multiple times |
| */ |
| private boolean clientActive = false; |
| |
| /** |
| * Keep track of whether we have activated OLE or not as some applications |
| * will only allow single activations. |
| */ |
| private boolean oleActivated = false; |
| |
| private IPartListener partListener = new IPartListener() { |
| public void partActivated(IWorkbenchPart part) { |
| activateClient(part); |
| } |
| public void partBroughtToTop(IWorkbenchPart part) { |
| } |
| public void partClosed(IWorkbenchPart part) { |
| } |
| public void partOpened(IWorkbenchPart part) { |
| } |
| public void partDeactivated(IWorkbenchPart part) { |
| deactivateClient(part); |
| } |
| }; |
| |
| private static final String RENAME_ERROR_TITLE = |
| WorkbenchMessages.getString("OleEditor.errorSaving"); //$NON-NLS-1$ |
| private static final String OLE_EXCEPTION_TITLE = |
| WorkbenchMessages.getString("OleEditor.oleExceptionTitle"); //$NON-NLS-1$ |
| private static final String OLE_EXCEPTION_MESSAGE = |
| WorkbenchMessages.getString("OleEditor.oleExceptionMessage"); //$NON-NLS-1$ |
| private static final String SAVE_ERROR_TITLE = |
| WorkbenchMessages.getString("OleEditor.savingTitle"); //$NON-NLS-1$ |
| private static final String SAVE_ERROR_MESSAGE = |
| WorkbenchMessages.getString("OleEditor.savingMessage"); //$NON-NLS-1$ |
| |
| /** |
| * Return a new ole editor. |
| */ |
| public OleEditor() { |
| } |
| |
| private void activateClient(IWorkbenchPart part) { |
| if (part == this) { |
| oleActivate(); |
| this.clientActive = true; |
| } |
| } |
| /** |
| * createPartControl method comment. |
| */ |
| public void createPartControl(Composite parent) { |
| |
| // Create a frame. |
| clientFrame = new OleFrame(parent, SWT.CLIP_CHILDREN); |
| clientFrame.setBackground( |
| JFaceColors.getBannerBackground(clientFrame.getDisplay())); |
| |
| initializeWorkbenchMenus(); |
| |
| // Set the input file. |
| IEditorInput input = getEditorInput(); |
| if (input instanceof IFileEditorInput) { |
| setResource(((IFileEditorInput) input).getFile()); |
| resource.getWorkspace().addResourceChangeListener(resourceListener); |
| } |
| |
| createClientSite(); |
| } |
| |
| /** |
| * Create the client site for the reciever |
| */ |
| |
| private void createClientSite() { |
| //If there was an OLE Error or nothing has been created yet |
| if (clientFrame == null || clientFrame.isDisposed()) |
| return; |
| // Create a OLE client site. |
| clientSite = new OleClientSite(clientFrame, SWT.NONE, source); |
| clientSite.setBackground( |
| JFaceColors.getBannerBackground(clientFrame.getDisplay())); |
| |
| } |
| |
| private void deactivateClient(IWorkbenchPart part) { |
| //Check the client active flag. Set it to false when we have deactivated |
| //to prevent multiple deactivations. |
| if (part == this && clientActive) { |
| if(clientSite != null) |
| clientSite.deactivateInPlaceClient(); |
| this.clientActive = false; |
| this.oleActivated = false; |
| } |
| } |
| /** |
| * Display an error dialog with the supplied title and message. |
| */ |
| private void displayErrorDialog(String title, String message) { |
| Shell parent = null; |
| if(getClientSite() != null) |
| parent = getClientSite().getShell(); |
| MessageDialog.openError(parent, title, message); |
| } |
| /** |
| * @see IWorkbenchPart#dispose |
| */ |
| public void dispose() { |
| if (resource != null) |
| resource.getWorkspace().removeResourceChangeListener(resourceListener); |
| |
| //can dispose the title image because it was created in init |
| if (oleTitleImage != null) { |
| oleTitleImage.dispose(); |
| oleTitleImage = null; |
| } |
| |
| if (getSite() != null && getSite().getPage() != null) |
| getSite().getPage().removePartListener(partListener); |
| |
| } |
| /** |
| * Print this object's contents |
| */ |
| public void doPrint() { |
| if(clientSite == null) |
| return; |
| BusyIndicator.showWhile(clientSite.getDisplay(), new Runnable() { |
| public void run() { |
| clientSite.exec(OLE.OLECMDID_PRINT, OLE.OLECMDEXECOPT_PROMPTUSER, null, null); |
| // note: to check for success: above == SWTOLE.S_OK |
| } |
| }); |
| } |
| /** |
| * Save the viewer's contents to the source file system file |
| */ |
| public void doSave(final IProgressMonitor monitor) { |
| if(clientSite == null) |
| return; |
| BusyIndicator.showWhile(clientSite.getDisplay(), new Runnable() { |
| public void run() { |
| |
| //Do not try and use the component provided save if the source has |
| //changed in Eclipse |
| if (!sourceChanged) { |
| int result = clientSite.queryStatus(OLE.OLECMDID_SAVE); |
| if ((result & OLE.OLECMDF_ENABLED) != 0) { |
| result = |
| clientSite.exec(OLE.OLECMDID_SAVE, OLE.OLECMDEXECOPT_PROMPTUSER, null, null); |
| if (result == OLE.S_OK) { |
| try { |
| resource.refreshLocal(IResource.DEPTH_ZERO, monitor); |
| } catch (CoreException ex) { |
| } |
| return; |
| } else { |
| displayErrorDialog( |
| OLE_EXCEPTION_TITLE, |
| OLE_EXCEPTION_MESSAGE + String.valueOf(result)); |
| return; |
| } |
| } |
| } |
| if (saveFile(source)) { |
| try { |
| resource.refreshLocal(IResource.DEPTH_ZERO, monitor); |
| } catch (CoreException ex) { |
| } |
| } else |
| displayErrorDialog(SAVE_ERROR_TITLE, SAVE_ERROR_MESSAGE + source.getName()); |
| } |
| }); |
| } |
| /** |
| * Save the viewer's contents into the provided resource. |
| */ |
| public void doSaveAs() { |
| if(clientSite == null) |
| return; |
| WorkspaceModifyOperation op = saveNewFileOperation(); |
| Shell shell = clientSite.getShell(); |
| try { |
| new ProgressMonitorDialog(shell).run(false, true, op); |
| } catch (InterruptedException interrupt) { |
| //Nothing to reset so do nothing |
| } catch (InvocationTargetException invocationException) { |
| MessageDialog.openError( |
| shell, |
| RENAME_ERROR_TITLE, |
| invocationException.getTargetException().getMessage()); |
| } |
| |
| } |
| /** |
| * Answer self's client site |
| * |
| * @return org.eclipse.swt.ole.win32.OleClientSite |
| */ |
| public OleClientSite getClientSite() { |
| return clientSite; |
| } |
| /** |
| * Answer the file system representation of self's input element |
| * |
| * @return java.io.File |
| */ |
| public File getSourceFile() { |
| return source; |
| } |
| /* (non-Javadoc) |
| * Sets the cursor and selection state for this editor to the passage defined |
| * by the given marker. |
| * |
| * @see IEditorPart |
| */ |
| public void gotoMarker(IMarker marker) { |
| } |
| |
| private void handleWord() { |
| OleAutomation dispInterface = new OleAutomation(clientSite); |
| // Get Application |
| int[] appId = dispInterface.getIDsOfNames(new String[]{"Application"}); //$NON-NLS-1$ |
| if (appId != null) { |
| Variant pVarResult = dispInterface.getProperty(appId[0]); |
| if (pVarResult != null) { |
| OleAutomation application = pVarResult.getAutomation(); |
| int[] dispid = application.getIDsOfNames(new String[] {"DisplayScrollBars"}); //$NON-NLS-1$ |
| if (dispid != null) { |
| Variant rgvarg = new Variant(true); |
| application.setProperty(dispid[0], rgvarg); |
| } |
| application.dispose(); |
| } |
| } |
| dispInterface.dispose(); |
| } |
| |
| /* (non-Javadoc) |
| * Initializes the editor when created from scratch. |
| * |
| * This method is called soon after part construction and marks |
| * the start of the extension lifecycle. At the end of the |
| * extension lifecycle <code>shutdown</code> will be invoked |
| * to terminate the lifecycle. |
| * |
| * @param container an interface for communication with the part container |
| * @param input The initial input element for the editor. In most cases |
| * it is an <code>IFile</code> but other types are acceptable. |
| * @see IWorkbenchPart#shutdown |
| */ |
| public void init(IEditorSite site, IEditorInput input) |
| throws PartInitException { |
| // Check input. |
| if (!(input instanceof IFileEditorInput)) |
| throw new PartInitException( |
| WorkbenchMessages.format("OleEditor.invalidInput", new Object[] { input })); //$NON-NLS-1$ |
| //$NON-NLS-1$ |
| |
| IFile file = (((IFileEditorInput) input).getFile()); |
| |
| //Cannot create this with a file and no physical location |
| if(file.getLocation() == null || !(new File(file.getLocation().toOSString()).exists())) |
| throw new PartInitException( |
| WorkbenchMessages.format("OleEditor.noFileInput", new Object[] { file.getLocation() })); //$NON-NLS-1$ |
| |
| // Save input. |
| setSite(site); |
| setInput(input); |
| |
| // Update titles. |
| setTitle(input.getName()); |
| setTitleToolTip(input.getToolTipText()); |
| ImageDescriptor desc = input.getImageDescriptor(); |
| if (desc != null) { |
| oleTitleImage = desc.createImage(); |
| setTitleImage(oleTitleImage); |
| } |
| |
| // Listen for part activation. |
| site.getPage().addPartListener(partListener); |
| |
| } |
| /** |
| * Initialize the workbench menus for proper merging |
| */ |
| protected void initializeWorkbenchMenus() { |
| //If there was an OLE Error or nothing has been created yet |
| if (clientFrame == null || clientFrame.isDisposed()) |
| return; |
| // Get the browser menubar. If one does not exist then |
| // create it. |
| Shell shell = clientFrame.getShell(); |
| Menu menuBar = shell.getMenuBar(); |
| if (menuBar == null) { |
| menuBar = new Menu(shell, SWT.BAR); |
| shell.setMenuBar(menuBar); |
| } |
| |
| // Swap the file and window menus. |
| MenuItem[] windowMenu = new MenuItem[1]; |
| MenuItem[] fileMenu = new MenuItem[1]; |
| Vector containerItems = new Vector(); |
| |
| IWorkbenchWindow window = getSite().getWorkbenchWindow(); |
| |
| for (int i = 0; i < menuBar.getItemCount(); i++) { |
| MenuItem item = menuBar.getItem(i); |
| String id = ""; //$NON-NLS-1$ |
| if (item.getData() instanceof IMenuManager) |
| id = ((IMenuManager) item.getData()).getId(); |
| if (id.equals(IWorkbenchActionConstants.M_FILE)) |
| fileMenu[0] = item; |
| else if (id.equals(IWorkbenchActionConstants.M_WINDOW)) |
| windowMenu[0] = item; |
| else { |
| if (window.isApplicationMenu(id)) { |
| containerItems.addElement(item); |
| } |
| } |
| } |
| MenuItem[] containerMenu = new MenuItem[containerItems.size()]; |
| containerItems.copyInto(containerMenu); |
| clientFrame.setFileMenus(fileMenu); |
| clientFrame.setContainerMenus(containerMenu); |
| clientFrame.setWindowMenus(windowMenu); |
| } |
| /* (non-Javadoc) |
| * Returns whether the contents of this editor have changed since the last save |
| * operation. As this is an external editor and we have no way of knowing return true |
| * if there is something to save to. |
| * |
| * @see IEditorPart |
| */ |
| public boolean isDirty() { |
| /*Return only if we have a clientSite which is dirty |
| as this can be asked before anything is opened*/ |
| return this.clientSite != null; |
| } |
| /* (non-Javadoc) |
| * Returns whether the "save as" operation is supported by this editor. We assume we |
| * can always save a file whether it will be via OLE or not. |
| * |
| * @see IEditorPart |
| */ |
| public boolean isSaveAsAllowed() { |
| return true; |
| } |
| /** |
| * Since we don't know when a change has been made, always answer true |
| */ |
| public boolean isSaveNeeded() { |
| //Answer false if it was not opened and true only if it is dirty |
| return getClientSite() != null && isDirty(); |
| } |
| /** |
| * Save the supplied file using the SWT API. |
| * @param file java.io.File |
| */ |
| private boolean saveFile(File file) { |
| |
| File tempFile = new File(file.getAbsolutePath() + ".tmp"); //$NON-NLS-1$ |
| file.renameTo(tempFile); |
| boolean saved = false; |
| if (OLE.isOleFile(file) || usesStorageFiles(clientSite.getProgramID())) { |
| saved = clientSite.save(file, true); |
| } else { |
| saved = clientSite.save(file, false); |
| } |
| |
| if (saved) { |
| // save was successful so discard the backup |
| tempFile.delete(); |
| return true; |
| } else { |
| // save failed so restore the backup |
| tempFile.renameTo(file); |
| return false; |
| } |
| } |
| /** |
| * Save the new File using the client site. |
| */ |
| private WorkspaceModifyOperation saveNewFileOperation() { |
| |
| return new WorkspaceModifyOperation() { |
| public void execute(final IProgressMonitor monitor) throws CoreException { |
| SaveAsDialog dialog = new SaveAsDialog(clientFrame.getShell()); |
| IFileEditorInput input = (IFileEditorInput)getEditorInput(); |
| IFile sFile = input.getFile(); |
| dialog.setOriginalFile(sFile); |
| dialog.open(); |
| |
| IPath newPath = dialog.getResult(); |
| if(newPath == null) |
| return; |
| |
| if (dialog.getReturnCode() == Dialog.OK) { |
| String projectName = newPath.segment(0); |
| newPath = newPath.removeFirstSegments(1); |
| IProject project = resource.getWorkspace().getRoot().getProject(projectName); |
| newPath = project.getLocation().append(newPath); |
| File newFile = newPath.toFile(); |
| if (saveFile(newFile)) { |
| IFile newResource = resource.getWorkspace().getRoot().getFileForLocation(newPath); |
| if (newResource != null) { |
| sourceChanged(newResource); |
| newResource.refreshLocal(IResource.DEPTH_ZERO, monitor); |
| } |
| } else { |
| displayErrorDialog(SAVE_ERROR_TITLE, SAVE_ERROR_MESSAGE + newFile.getName()); |
| return; |
| } |
| } |
| } |
| }; |
| |
| } |
| /** |
| * Asks the part to take focus within the workbench. |
| */ |
| public void setFocus() {} |
| |
| /** |
| * Make ole active so that the controls are rendered. |
| */ |
| private void oleActivate() { |
| //If there was an OLE Error or nothing has been created yet |
| if (clientSite == null || clientFrame == null || clientFrame.isDisposed()) |
| return; |
| |
| if (!oleActivated) { |
| clientSite.doVerb(OLE.OLEIVERB_SHOW); |
| oleActivated = true; |
| String progId = clientSite.getProgramID(); |
| if (progId != null && progId.startsWith("Word.Document")) { //$NON-NLS-1$ |
| handleWord(); |
| } |
| } |
| } |
| |
| /** |
| * Set the file resource that this object is displaying |
| */ |
| protected void setResource(IFile file) { |
| resource = file; |
| source = new File(file.getLocation().toOSString()); |
| } |
| /** |
| * See if it is one of the known types that use OLE Storage. |
| */ |
| private static boolean usesStorageFiles(String progID) { |
| return (progID != null && (progID.startsWith("Word.", 0) //$NON-NLS-1$ |
| || progID.startsWith("MSGraph", 0) //$NON-NLS-1$ |
| || progID.startsWith("PowerPoint", 0) //$NON-NLS-1$ |
| || progID.startsWith("Excel", 0))); //$NON-NLS-1$ |
| } |
| |
| /** |
| * The source has changed to the newFile. Update |
| * editors and set any required flags |
| */ |
| private void sourceChanged(IFile newFile) { |
| |
| FileEditorInput newInput = new FileEditorInput(newFile); |
| setInput(newInput); |
| setResource(newFile); |
| sourceChanged = true; |
| setTitle(newInput.getName()); |
| |
| } |
| |
| /* |
| * See IEditorPart.isSaveOnCloseNeeded() |
| */ |
| public boolean isSaveOnCloseNeeded() { |
| return !sourceDeleted && super.isSaveOnCloseNeeded(); |
| } |
| |
| /** |
| * Posts the update code "behind" the running operation. |
| * |
| * @param runnable the update code |
| */ |
| private void update(Runnable runnable) { |
| IWorkbench workbench = PlatformUI.getWorkbench(); |
| IWorkbenchWindow[] windows = workbench.getWorkbenchWindows(); |
| if (windows != null && windows.length > 0) { |
| Display display = windows[0].getShell().getDisplay(); |
| display.asyncExec(runnable); |
| } else |
| runnable.run(); |
| } |
| |
| } |
