| /******************************************************************************* |
| * Copyright (c) 2005 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.bpel.common.ui.editmodel; |
| |
| import java.io.File; |
| import java.io.IOException; |
| |
| import org.eclipse.bpel.common.ui.CommonUIPlugin; |
| import org.eclipse.bpel.common.ui.Messages; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IPartListener; |
| import org.eclipse.ui.IWindowListener; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.dialogs.SaveAsDialog; |
| |
| |
| |
| /** |
| * Implements an activation listener and hooks it to an editor. |
| * |
| * Calls the API in ISynchonizationHandler when needed to refresh |
| * the model, close the editor, and to save the model. |
| */ |
| class SynchronizationManager { |
| |
| /** */ |
| private ActivationListener partListener; |
| |
| public SynchronizationManager(IEditorPart editor,EditModel editModel,SynchronizationHandler handler) { |
| partListener = new ActivationListener(this,editor,handler,editModel); |
| editor.getSite().getWorkbenchWindow().getPartService().addPartListener(partListener); |
| PlatformUI.getWorkbench().addWindowListener(partListener); |
| } |
| protected void dispose() { |
| if (partListener.editor == null) |
| throw new IllegalArgumentException("editor cannot be null"); //$NON-NLS-1$ |
| partListener.editor.getSite().getWorkbenchWindow().getPartService().removePartListener(partListener); |
| PlatformUI.getWorkbench().removeWindowListener(partListener); |
| } |
| private static class ActivationListener implements IPartListener, IWindowListener { |
| /** */ |
| private boolean handlingActivation = false; |
| /** */ |
| private IWorkbenchPart activePart = null; |
| /** */ |
| private SynchronizationManager manager; |
| /** */ |
| private IEditorPart editor; |
| /** */ |
| private SynchronizationHandler handler; |
| /** */ |
| private EditModel editModel; |
| |
| ActivationListener(SynchronizationManager manager,IEditorPart editor,SynchronizationHandler handler,EditModel editModel) { |
| this.editModel = editModel; |
| this.manager = manager; |
| this.editor = editor; |
| this.handler = handler; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IPartListener#partActivated(org.eclipse.ui.IWorkbenchPart) |
| */ |
| public void partActivated(IWorkbenchPart part) { |
| activePart = part; |
| handleActivated(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IPartListener#partBroughtToTop(org.eclipse.ui.IWorkbenchPart) |
| */ |
| public void partBroughtToTop(IWorkbenchPart part) { |
| } |
| |
| /** |
| * When a WorkbenchPart is closed, check if that part is |
| * an editor using the model provided by the ResourceInfo object. |
| * If it is, remove that editor from the editor list. |
| */ |
| public void partClosed(IWorkbenchPart part) { |
| if (part instanceof IEditorPart) { |
| if(editor == part) |
| manager.dispose(); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IPartListener#partDeactivated(org.eclipse.ui.IWorkbenchPart) |
| */ |
| public void partDeactivated(IWorkbenchPart part) { |
| activePart = null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IPartListener#partOpened(org.eclipse.ui.IWorkbenchPart) |
| */ |
| public void partOpened(IWorkbenchPart part) { |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IWindowListener#windowActivated(org.eclipse.ui.IWorkbenchWindow) |
| */ |
| public void windowActivated(IWorkbenchWindow window) { |
| if (!handlingActivation) |
| handleActivated(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IWindowListener#windowDeactivated(org.eclipse.ui.IWorkbenchWindow) |
| */ |
| public void windowDeactivated(IWorkbenchWindow window) { |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IWindowListener#windowClosed(org.eclipse.ui.IWorkbenchWindow) |
| */ |
| public void windowClosed(IWorkbenchWindow window) { |
| if (editor.getSite().getWorkbenchWindow() == window) { |
| manager.dispose(); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IWindowListener#windowOpened(org.eclipse.ui.IWorkbenchWindow) |
| */ |
| public void windowOpened(IWorkbenchWindow window) { |
| } |
| /** |
| * Handles when the specified AbstractRulesEditor becomes active. |
| * The handler first checks to see if the editor input has been |
| * deleted, then refreshes the workspace cache of the input to |
| * allow the ResourceChangeListener to handle any updates to the |
| * file. |
| */ |
| void handleActivated() { |
| if (editor == activePart) { |
| handlingActivation = true; |
| |
| try { |
| ResourceInfo[] resourceInfos = editModel.getResourceInfos(); |
| for (int i = 0; i < resourceInfos.length; i++) { |
| handleActivated(resourceInfos[i]); |
| } |
| } catch (CoreException e) { |
| CommonUIPlugin.log(e); |
| } catch (IOException e) { |
| CommonUIPlugin.log(e); |
| } |
| handlingActivation = false; |
| } |
| } |
| void handleActivated(ResourceInfo resourceInfo) throws CoreException, IOException { |
| boolean exists = false; |
| long lastModified = 0; |
| IPath location = resourceInfo.getFile().getLocation(); |
| if(location != null) { |
| File localFile = location.toFile(); |
| exists = localFile.exists(); |
| lastModified = localFile.lastModified(); |
| } |
| |
| // Careful: avoid using editor.getFileInput().exists() since it causes |
| // the file cache to be updated and fires the resource change listener. |
| // This prevents us from prompting the user for action if the editor is |
| // visible. |
| if (resourceInfo.getFileExists() && !exists) { //File was deleted |
| String[] buttons = { Messages.SynchronizationManager_saveButtonLabel, IDialogConstants.CLOSE_LABEL }; |
| |
| // Bugzilla 330513 |
| // avoid using activeWindow to get a shell - there are cases where these |
| // error dialogs are opened before the active window has been created |
| // (e.g. resource load failures during editor startup) |
| while (true) { |
| MessageDialog dialog = new MessageDialog( |
| editor.getEditorSite().getShell(), |
| Messages.SynchronizationManager_deleted_title, |
| null, // accept the default windowing system icon |
| Messages.SynchronizationManager_deleted_message, |
| MessageDialog.QUESTION, |
| buttons, |
| 0); |
| |
| if (dialog.open() == Window.OK) { |
| SaveAsDialog saveAsDialog = new SaveAsDialog(editor.getEditorSite().getShell()); |
| saveAsDialog.setOriginalFile(resourceInfo.getFile()); |
| saveAsDialog.open(); |
| |
| IPath path = saveAsDialog.getResult(); |
| if (path != null) { |
| boolean saveSuccess = handler.saveFileAs( |
| resourceInfo, |
| ResourcesPlugin.getWorkspace().getRoot().getFile(path)); |
| if (saveSuccess) { |
| resourceInfo.resetSynchronizeStamp(); |
| break; |
| } |
| } |
| } else { |
| handler.closeEditor(); |
| break; |
| } |
| } |
| } else if (lastModified != resourceInfo.getSynchronizeStamp()) { |
| String msg = NLS.bind(Messages.SynchronizationManager_refresh_message, (new String[]{ resourceInfo.getFile().toString()})); |
| boolean refresh = MessageDialog.openQuestion( |
| editor.getEditorSite().getShell(), |
| Messages.SynchronizationManager_refresh_title, |
| msg); |
| |
| if (refresh) { |
| handler.refresh(resourceInfo); |
| resourceInfo.resetSynchronizeStamp(); |
| } else { |
| /* |
| * Update Synchronize Stamp so further editor activations |
| * will not display prompt to refresh. |
| */ |
| resourceInfo.resetSynchronizeStamp(); |
| } |
| } |
| IFile file = resourceInfo.getFile(); |
| if (file.exists() && (!file.isLocal(IResource.DEPTH_ZERO) || !resourceInfo.getFile().isSynchronized(IResource.DEPTH_ZERO))) |
| file.refreshLocal(IResource.DEPTH_ZERO, new NullProgressMonitor()); |
| } |
| } |
| } |