Java tutorial
/******************************************************************************* * Copyright (c) 2003, 2008 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 com.liferay.ide.ui.editor; import com.liferay.ide.core.model.IBaseModel; import com.liferay.ide.core.model.IEditable; import com.liferay.ide.core.model.IEditingModel; import com.liferay.ide.core.model.IModelChangeProvider; import com.liferay.ide.core.model.IModelChangedEvent; import com.liferay.ide.core.model.IModelChangedListener; import com.liferay.ide.ui.LiferayUIPlugin; import com.liferay.ide.ui.form.IDEFormEditor; import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; import org.eclipse.core.filebuffers.IDocumentSetupParticipant; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.IWorkspace; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; import org.eclipse.jface.dialogs.ErrorDialog; import org.eclipse.jface.dialogs.IMessageProvider; import org.eclipse.jface.text.BadLocationException; import org.eclipse.jface.text.IDocument; import org.eclipse.jface.text.TextUtilities; import org.eclipse.jface.text.source.IAnnotationModel; import org.eclipse.jface.window.Window; import org.eclipse.osgi.util.NLS; import org.eclipse.swt.widgets.Shell; import org.eclipse.text.edits.InsertEdit; import org.eclipse.text.edits.MalformedTreeException; import org.eclipse.text.edits.MoveSourceEdit; import org.eclipse.text.edits.MultiTextEdit; import org.eclipse.text.edits.TextEdit; import org.eclipse.ui.IEditorInput; import org.eclipse.ui.IFileEditorInput; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.actions.WorkspaceModifyOperation; import org.eclipse.ui.dialogs.SaveAsDialog; import org.eclipse.ui.editors.text.ForwardingDocumentProvider; import org.eclipse.ui.part.FileEditorInput; import org.eclipse.ui.texteditor.IDocumentProvider; import org.eclipse.ui.texteditor.IElementStateListener; /** * This class maintains objects associated with a single editor input. */ public abstract class InputContext { private IDEFormEditor fEditor; private IEditorInput fEditorInput; private IBaseModel fModel; private IModelChangedListener fModelListener; private IDocumentProvider fDocumentProvider; private IElementStateListener fElementListener; protected ArrayList fEditOperations = new ArrayList(); private boolean fValidated; private boolean fPrimary; private boolean fIsSourceMode; private boolean fMustSynchronize; class ElementListener implements IElementStateListener { public void elementContentAboutToBeReplaced(Object element) { } public void elementContentReplaced(Object element) { if (element != null && element.equals(fEditorInput)) doRevert(); } public void elementDeleted(Object element) { if (element != null && element.equals(fEditorInput)) dispose(); } public void elementDirtyStateChanged(Object element, boolean isDirty) { if (element != null && element.equals(fEditorInput)) fMustSynchronize = true; } public void elementMoved(Object originalElement, Object movedElement) { if (originalElement != null && originalElement.equals(fEditorInput)) { dispose(); fEditor.close(true); } } } public InputContext(IDEFormEditor editor, IEditorInput input, boolean primary) { this.fEditor = editor; this.fEditorInput = input; setPrimary(primary); } public abstract String getId(); public IEditorInput getInput() { return fEditorInput; } public IDEFormEditor getEditor() { return fEditor; } public IBaseModel getModel() { return fModel; } public IDocumentProvider getDocumentProvider() { return fDocumentProvider; } protected IDocumentProvider createDocumentProvider(IEditorInput input) { if (input instanceof IFileEditorInput) { return new ForwardingDocumentProvider(getPartitionName(), getDocumentSetupParticipant(), LiferayUIPlugin.getDefault().getTextFileDocumentProvider()); } return null; } protected IDocumentSetupParticipant getDocumentSetupParticipant() { return new IDocumentSetupParticipant() { public void setup(IDocument document) { } }; } protected abstract String getPartitionName(); protected abstract String getDefaultCharset(); protected abstract IBaseModel createModel(IEditorInput input) throws CoreException; protected void create() { fDocumentProvider = createDocumentProvider(fEditorInput); try { fDocumentProvider.connect(fEditorInput); fModel = createModel(fEditorInput); if (fModel instanceof IModelChangeProvider) { fModelListener = new IModelChangedListener() { public void modelChanged(IModelChangedEvent e) { if (e.getChangeType() != IModelChangedEvent.WORLD_CHANGED) { if (!fEditor.getLastDirtyState()) fEditor.fireSaveNeeded(fEditorInput, true); IModelChangeProvider provider = e.getChangeProvider(); if (provider instanceof IEditingModel) { // this is to guard against false notifications // when a revert operation is performed, focus is taken away from a FormEntry // and a text edit operation is falsely requested if (((IEditingModel) provider).isDirty()) addTextEditOperation(fEditOperations, e); } } } }; ((IModelChangeProvider) fModel).addModelChangedListener(fModelListener); } IAnnotationModel amodel = fDocumentProvider.getAnnotationModel(fEditorInput); if (amodel != null) amodel.connect(fDocumentProvider.getDocument(fEditorInput)); fElementListener = new ElementListener(); fDocumentProvider.addElementStateListener(fElementListener); } catch (CoreException e) { LiferayUIPlugin.logError(e); } } public synchronized boolean validateEdit() { if (!fValidated) { if (fEditorInput instanceof IFileEditorInput) { IFile file = ((IFileEditorInput) fEditorInput).getFile(); if (file.isReadOnly()) { Shell shell = fEditor.getEditorSite().getShell(); IStatus validateStatus = LiferayUIPlugin.getWorkspace().validateEdit(new IFile[] { file }, shell); fValidated = true; // to prevent loops if (validateStatus.getSeverity() != IStatus.OK) ErrorDialog.openError(shell, fEditor.getTitle(), null, validateStatus); return validateStatus.getSeverity() == IStatus.OK; } } } return true; } public void doSave(IProgressMonitor monitor) { try { IDocument doc = fDocumentProvider.getDocument(fEditorInput); fDocumentProvider.aboutToChange(fEditorInput); flushModel(doc); fDocumentProvider.saveDocument(monitor, fEditorInput, doc, true); fDocumentProvider.changed(fEditorInput); fValidated = false; } catch (CoreException e) { LiferayUIPlugin.logError(e); } } protected abstract void addTextEditOperation(ArrayList ops, IModelChangedEvent event); public void flushEditorInput() { if (fEditOperations.size() > 0) { IDocument doc = fDocumentProvider.getDocument(fEditorInput); fDocumentProvider.aboutToChange(fEditorInput); flushModel(doc); fDocumentProvider.changed(fEditorInput); fValidated = false; } else if ((fModel instanceof IEditable) && ((IEditable) fModel).isDirty()) { // When text edit operations are made that cancel each other out, // the editor is not undirtied // e.g. Extensions page: Move an element up and then move it down // back in the same position: Bug # 197831 ((IEditable) fModel).setDirty(false); } } protected void flushModel(IDocument doc) { boolean flushed = true; if (fEditOperations.size() > 0) { try { MultiTextEdit edit = new MultiTextEdit(); if (isNewlineNeeded(doc)) insert(edit, new InsertEdit(doc.getLength(), TextUtilities.getDefaultLineDelimiter(doc))); for (int i = 0; i < fEditOperations.size(); i++) { insert(edit, (TextEdit) fEditOperations.get(i)); } if (fModel instanceof IEditingModel) ((IEditingModel) fModel).setStale(true); edit.apply(doc); fEditOperations.clear(); } catch (MalformedTreeException e) { LiferayUIPlugin.logError(e); flushed = false; } catch (BadLocationException e) { LiferayUIPlugin.logError(e); flushed = false; } } // If no errors were encountered flushing the model, then undirty the // model. This needs to be done regardless of whether there are any // edit operations or not; since, the contributed actions need to be // updated and the editor needs to be undirtied if (flushed && (fModel instanceof IEditable)) { ((IEditable) fModel).setDirty(false); } } public static int getInsertOffset(IDocument doc) { int offset = doc.getLength(); for (int i = doc.getNumberOfLines() - 1; i >= 0; i--) { try { if (doc.get(doc.getLineOffset(i), doc.getLineLength(i)).trim().length() > 0) { break; } offset = doc.getLineOffset(i); } catch (BadLocationException e) { } } return offset; } public static boolean isNewlineNeeded(IDocument doc) throws BadLocationException { int line = doc.getLineOfOffset(getInsertOffset(doc)); return doc.get(doc.getLineOffset(line), doc.getLineLength(line)).trim().length() > 0; } protected static void insert(TextEdit parent, TextEdit edit) { if (!parent.hasChildren()) { parent.addChild(edit); if (edit instanceof MoveSourceEdit) { parent.addChild(((MoveSourceEdit) edit).getTargetEdit()); } return; } TextEdit[] children = parent.getChildren(); // First dive down to find the right parent. for (int i = 0; i < children.length; i++) { TextEdit child = children[i]; if (covers(child, edit)) { insert(child, edit); return; } } // We have the right parent. Now check if some of the children have to // be moved under the new edit since it is covering it. for (int i = children.length - 1; i >= 0; i--) { TextEdit child = children[i]; if (covers(edit, child)) { parent.removeChild(i); edit.addChild(child); } } parent.addChild(edit); if (edit instanceof MoveSourceEdit) { parent.addChild(((MoveSourceEdit) edit).getTargetEdit()); } } protected static boolean covers(TextEdit thisEdit, TextEdit otherEdit) { if (thisEdit.getLength() == 0) // an insertion point can't cover anything return false; int thisOffset = thisEdit.getOffset(); int thisEnd = thisEdit.getExclusiveEnd(); if (otherEdit.getLength() == 0) { int otherOffset = otherEdit.getOffset(); return thisOffset < otherOffset && otherOffset < thisEnd; } int otherOffset = otherEdit.getOffset(); int otherEnd = otherEdit.getExclusiveEnd(); return thisOffset <= otherOffset && otherEnd <= thisEnd; } public boolean mustSave() { if (!fIsSourceMode) { if (fModel instanceof IEditable) { if (((IEditable) fModel).isDirty()) { return true; } } } return fEditOperations.size() > 0 || fDocumentProvider.canSaveDocument(fEditorInput); } public void dispose() { IAnnotationModel amodel = fDocumentProvider.getAnnotationModel(fEditorInput); if (amodel != null) amodel.disconnect(fDocumentProvider.getDocument(fEditorInput)); fDocumentProvider.removeElementStateListener(fElementListener); fDocumentProvider.disconnect(fEditorInput); if (fModelListener != null && fModel instanceof IModelChangeProvider) { ((IModelChangeProvider) fModel).removeModelChangedListener(fModelListener); //if (undoManager != null) //undoManager.disconnect((IModelChangeProvider) model); } if (fModel != null) fModel.dispose(); } /** * @return Returns the primary. */ public boolean isPrimary() { return fPrimary; } /** * @param primary The primary to set. */ public void setPrimary(boolean primary) { this.fPrimary = primary; } public boolean setSourceEditingMode(boolean sourceMode) { fIsSourceMode = sourceMode; if (sourceMode) { // entered source editing mode; in this mode, // this context's document will be edited directly // in the source editor. All changes in the model // are caused by reconciliation and should not be // fired to the world. flushModel(fDocumentProvider.getDocument(fEditorInput)); fMustSynchronize = true; return true; } // leaving source editing mode; if the document // has been modified while in this mode, // fire the 'world changed' event from the model // to cause all the model listeners to become stale. return synchronizeModelIfNeeded(); } private boolean synchronizeModelIfNeeded() { if (fMustSynchronize) { boolean result = synchronizeModel(fDocumentProvider.getDocument(fEditorInput)); fMustSynchronize = false; return result; } return true; } public void doRevert() { fMustSynchronize = true; synchronizeModelIfNeeded(); /* if (model instanceof IEditable) { ((IEditable)model).setDirty(false); } */ } public boolean isInSourceMode() { return fIsSourceMode; } public boolean isModelCorrect() { synchronizeModelIfNeeded(); return fModel != null ? fModel.isValid() : false; } protected boolean synchronizeModel(IDocument doc) { return true; } public boolean matches(IResource resource) { if (fEditorInput instanceof IFileEditorInput) { IFileEditorInput finput = (IFileEditorInput) fEditorInput; IFile file = finput.getFile(); if (file.equals(resource)) return true; } return false; } /** * @return Returns the validated. */ public boolean isValidated() { return fValidated; } /** * @param validated The validated to set. */ public void setValidated(boolean validated) { this.fValidated = validated; } public String getLineDelimiter() { if (fDocumentProvider != null) { IDocument document = fDocumentProvider.getDocument(fEditorInput); if (document != null) { return TextUtilities.getDefaultLineDelimiter(document); } } return System.getProperty("line.separator"); //$NON-NLS-1$ } /** * @param input * @throws CoreException */ private void updateInput(IEditorInput newInput) throws CoreException { deinitializeDocumentProvider(); fEditorInput = newInput; initializeDocumentProvider(); } /** * */ private void deinitializeDocumentProvider() { IAnnotationModel amodel = fDocumentProvider.getAnnotationModel(fEditorInput); if (amodel != null) { amodel.disconnect(fDocumentProvider.getDocument(fEditorInput)); } fDocumentProvider.removeElementStateListener(fElementListener); fDocumentProvider.disconnect(fEditorInput); } /** * @throws CoreException */ private void initializeDocumentProvider() throws CoreException { fDocumentProvider.connect(fEditorInput); IAnnotationModel amodel = fDocumentProvider.getAnnotationModel(fEditorInput); if (amodel != null) { amodel.connect(fDocumentProvider.getDocument(fEditorInput)); } fDocumentProvider.addElementStateListener(fElementListener); } /** * @param monitor */ public void doSaveAs(IProgressMonitor monitor) throws Exception { // Get the editor shell Shell shell = getEditor().getSite().getShell(); // Create the save as dialog SaveAsDialog dialog = new SaveAsDialog(shell); // Set the initial file name to the original file name IFile file = null; if (fEditorInput instanceof IFileEditorInput) { file = ((IFileEditorInput) fEditorInput).getFile(); dialog.setOriginalFile(file); } // Create the dialog dialog.create(); // Warn the user if the underlying file does not exist if (fDocumentProvider.isDeleted(fEditorInput) && (file != null)) { String message = NLS.bind("File does not exist: {0}", file.getName()); //$NON-NLS-1$ dialog.setErrorMessage(null); dialog.setMessage(message, IMessageProvider.WARNING); } // Open the dialog if (dialog.open() == Window.OK) { // Get the path to where the new file will be stored IPath path = dialog.getResult(); handleSaveAs(monitor, path); } } /** * @param monitor * @param path * @throws Exception * @throws CoreException * @throws InterruptedException * @throws InvocationTargetException */ private void handleSaveAs(IProgressMonitor monitor, IPath path) throws Exception, CoreException, InterruptedException, InvocationTargetException { // Ensure a new location was selected if (path == null) { monitor.setCanceled(true); throw new Exception("Location not set."); //$NON-NLS-1$ } // Resolve the new file location IWorkspace workspace = ResourcesPlugin.getWorkspace(); IFile newFile = workspace.getRoot().getFile(path); // Create the new editor input final IEditorInput newInput = new FileEditorInput(newFile); // Send notice of editor input changes fDocumentProvider.aboutToChange(newInput); // Flush any unsaved changes flushModel(fDocumentProvider.getDocument(fEditorInput)); try { // Execute the workspace modification in a separate thread PlatformUI.getWorkbench().getProgressService() .busyCursorWhile(createWorkspaceModifyOperation(newInput)); monitor.setCanceled(false); // Store the new editor input in this context updateInput(newInput); } catch (InterruptedException e) { monitor.setCanceled(true); throw e; } catch (InvocationTargetException e) { monitor.setCanceled(true); throw e; } finally { fDocumentProvider.changed(newInput); } } /** * @param newInput * @return */ private WorkspaceModifyOperation createWorkspaceModifyOperation(final IEditorInput newInput) { WorkspaceModifyOperation operation = new WorkspaceModifyOperation() { public void execute(final IProgressMonitor monitor) throws CoreException { // Save the old editor input content to the new editor input // location fDocumentProvider.saveDocument(monitor, // New editor input location newInput, // Old editor input content fDocumentProvider.getDocument(fEditorInput), true); } }; return operation; } }