| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.netbeans.modules.nbform; |
| |
| import com.sun.source.tree.AnnotationTree; |
| import com.sun.source.tree.ClassTree; |
| import com.sun.source.tree.CompilationUnitTree; |
| import com.sun.source.tree.MethodTree; |
| import com.sun.source.tree.ModifiersTree; |
| import com.sun.source.tree.Tree; |
| import com.sun.source.util.SourcePositions; |
| import java.awt.Cursor; |
| import java.awt.Dialog; |
| import java.awt.EventQueue; |
| import java.awt.event.ActionEvent; |
| import java.beans.BeanInfo; |
| import java.beans.PropertyChangeEvent; |
| import java.beans.PropertyChangeListener; |
| import java.io.CharConversionException; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.Reader; |
| import java.io.Writer; |
| import java.lang.reflect.InvocationTargetException; |
| import java.nio.charset.Charset; |
| import java.text.MessageFormat; |
| import java.util.Collections; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| import javax.swing.AbstractAction; |
| import javax.swing.Action; |
| import javax.swing.JButton; |
| import javax.swing.JDialog; |
| import javax.swing.JEditorPane; |
| import javax.swing.JFrame; |
| import javax.swing.text.BadLocationException; |
| import javax.swing.text.EditorKit; |
| import javax.swing.text.Position; |
| import javax.swing.text.StyledDocument; |
| import org.netbeans.api.editor.fold.Fold; |
| import org.netbeans.api.editor.fold.FoldHierarchy; |
| import org.netbeans.api.editor.fold.FoldHierarchyEvent; |
| import org.netbeans.api.editor.fold.FoldUtilities; |
| import org.netbeans.api.editor.guards.GuardedSectionManager; |
| import org.netbeans.api.editor.guards.SimpleSection; |
| import org.netbeans.api.java.classpath.ClassPath; |
| import org.netbeans.api.java.queries.SourceLevelQuery; |
| import org.netbeans.api.java.source.CancellableTask; |
| import org.netbeans.api.java.source.CodeStyle; |
| import org.netbeans.api.java.source.JavaSource; |
| import org.netbeans.api.java.source.TreeUtilities; |
| import org.netbeans.api.java.source.WorkingCopy; |
| import org.netbeans.api.project.FileOwnerQuery; |
| import org.netbeans.api.project.Project; |
| import org.netbeans.api.project.libraries.Library; |
| import org.netbeans.api.project.libraries.LibraryManager; |
| import org.netbeans.api.queries.FileEncodingQuery; |
| import org.netbeans.core.api.multiview.MultiViewHandler; |
| import org.netbeans.core.api.multiview.MultiViews; |
| import org.netbeans.core.spi.multiview.CloseOperationState; |
| import org.netbeans.core.spi.multiview.MultiViewElement; |
| import org.netbeans.core.spi.multiview.MultiViewElementCallback; |
| import org.netbeans.core.spi.multiview.MultiViewFactory; |
| import org.netbeans.core.spi.multiview.text.MultiViewEditorElement; |
| import org.netbeans.modules.form.CodeGenerator; |
| import org.netbeans.modules.form.EditorSupport; |
| import org.netbeans.modules.form.FormDataObject; |
| import org.netbeans.modules.form.FormDesigner; |
| import org.netbeans.modules.form.FormEditor; |
| import org.netbeans.modules.form.FormModel; |
| import org.netbeans.modules.form.FormUtils; |
| import org.netbeans.modules.form.PersistenceException; |
| import org.netbeans.modules.form.project.ClassPathUtils; |
| import org.netbeans.modules.form.project.ClassSource; |
| import org.netbeans.modules.nbform.project.ClassSourceResolver; |
| import org.netbeans.spi.editor.guards.GuardedEditorSupport; |
| import org.netbeans.spi.editor.guards.GuardedSectionsFactory; |
| import org.netbeans.spi.editor.guards.GuardedSectionsProvider; |
| import org.openide.DialogDescriptor; |
| import org.openide.DialogDisplayer; |
| import org.openide.ErrorManager; |
| import org.openide.NotifyDescriptor; |
| import org.openide.awt.Mnemonics; |
| import org.openide.awt.StatusDisplayer; |
| import org.openide.awt.UndoRedo; |
| import org.openide.cookies.CloseCookie; |
| import org.openide.cookies.EditorCookie; |
| import org.openide.cookies.OpenCookie; |
| import org.openide.cookies.PrintCookie; |
| import org.openide.cookies.SaveCookie; |
| import org.openide.filesystems.FileLock; |
| import org.openide.filesystems.FileObject; |
| import org.openide.filesystems.FileStateInvalidException; |
| import org.openide.filesystems.FileStatusEvent; |
| import org.openide.filesystems.FileStatusListener; |
| import org.openide.filesystems.FileSystem; |
| import org.openide.loaders.DataObject; |
| import org.openide.nodes.CookieSet; |
| import org.openide.nodes.Node; |
| import org.openide.nodes.NodeAdapter; |
| import org.openide.nodes.NodeListener; |
| import org.openide.text.CloneableEditorSupport; |
| import org.openide.text.DataEditorSupport; |
| import org.openide.text.PositionRef; |
| import org.openide.util.Exceptions; |
| import org.openide.util.Lookup; |
| import org.openide.util.Mutex; |
| import org.openide.util.NbBundle.Messages; |
| import org.openide.util.UserQuestionException; |
| import org.openide.windows.CloneableOpenSupport; |
| import org.openide.windows.CloneableTopComponent; |
| import org.openide.windows.Mode; |
| import org.openide.windows.TopComponent; |
| import org.openide.windows.TopComponentGroup; |
| import org.openide.windows.WindowManager; |
| import org.openide.xml.XMLUtil; |
| |
| /** |
| * |
| * @author Ian Formanek, Tomas Pavek |
| */ |
| |
| public final class FormEditorSupport extends DataEditorSupport implements EditorSupport, |
| EditorCookie.Observable, CloseCookie, PrintCookie { |
| |
| /** ID of the form designer (in the multiview) */ |
| static final String MV_FORM_ID = "form"; //NOI18N |
| /** ID of the java editor (in the multiview) */ |
| private static final String MV_JAVA_ID = "java"; // NOI18N |
| |
| private static final int JAVA_ELEMENT_INDEX = 0; |
| private static final int FORM_ELEMENT_INDEX = 2; |
| private int elementToOpen; // default element index when multiview TC is created |
| |
| /** Icon for the form editor multiview window */ |
| static final String iconURL = |
| "org/netbeans/modules/form/resources/form.gif"; // NOI18N |
| |
| /** The DataObject of the form */ |
| private FormDataObject formDataObject; |
| |
| /** The embracing multiview TopComponent (holds the form designer and |
| * java editor) - we remember the last active TopComponent (not all clones) */ |
| private CloneableTopComponent multiviewTC; |
| |
| /** |
| * Listener for node delegate's icon changes. It is responsible |
| * for synchronization of node's and multiviewTC's icons. |
| */ |
| private NodeListener nodeListener; |
| |
| private static PropertyChangeListener topcompsListener; |
| |
| private FoldHierarchyListener foldHierarchyListener; |
| |
| private UndoRedo.Manager editorUndoManager; |
| |
| private FormEditor formEditor; |
| |
| /** Set of opened FormEditorSupport instances (java or form opened) */ |
| private static final Set<FormEditorSupport> opened = Collections.synchronizedSet(new HashSet<FormEditorSupport>()); |
| |
| private static Map<FileSystem,FileStatusListener> fsToStatusListener = new HashMap<FileSystem,FileStatusListener>(); |
| |
| // -------------- |
| // constructor |
| |
| public FormEditorSupport(FormDataObject formDataObject) { |
| super(formDataObject, formDataObject.getLookup(), new Environment(formDataObject)); |
| setMIMEType("text/x-java"); // NOI18N |
| this.formDataObject = formDataObject; |
| this.cookies = formDataObject.getCookies(); |
| } |
| |
| // ---------- |
| // opening & saving interface methods |
| |
| /** Main entry method. Called by OpenCookie implementation - opens the form. |
| * |
| * @param forceFormElement determines whether we should force switch to form element. |
| * @see OpenCookie#open |
| */ |
| public void openFormEditor(boolean forceFormElement) { |
| boolean alreadyOpened = opened.contains(this); |
| boolean switchToForm = forceFormElement || !alreadyOpened; |
| if (switchToForm) { |
| elementToOpen = FORM_ELEMENT_INDEX; |
| } |
| long ms = System.currentTimeMillis(); |
| try { |
| showOpeningStatus("FMT_PreparingForm"); // NOI18N |
| |
| multiviewTC = openCloneableTopComponent(); |
| multiviewTC.requestActive(); |
| |
| registerNodeListener(); |
| |
| if (switchToForm) { |
| MultiViewHandler handler = MultiViews.findMultiViewHandler(multiviewTC); |
| handler.requestActive(handler.getPerspectives()[FORM_ELEMENT_INDEX]); |
| } |
| } finally { |
| hideOpeningStatus(); |
| } |
| Logger.getLogger(FormEditor.class.getName()).log(Level.FINER, "Opening form time 1: {0}ms", (System.currentTimeMillis()-ms)); // NOI18N |
| } |
| |
| private void registerNodeListener() { |
| if (formDataObject.isValid()) { |
| Node node = formDataObject.getNodeDelegate(); |
| multiviewTC.setIcon(node.getIcon(BeanInfo.ICON_COLOR_16x16)); |
| if (nodeListener == null) { |
| NodeListener listener = new NodeAdapter() { |
| @Override |
| public void propertyChange(final PropertyChangeEvent ev) { |
| Mutex.EVENT.writeAccess(new Runnable() { |
| @Override |
| public void run() { |
| if (Node.PROP_ICON.equals(ev.getPropertyName())) { |
| if (formDataObject.isValid() && (multiviewTC != null)) { |
| multiviewTC.setIcon(formDataObject.getNodeDelegate().getIcon(BeanInfo.ICON_COLOR_16x16)); |
| } |
| } |
| } |
| }); |
| } |
| }; |
| node.addNodeListener(org.openide.nodes.NodeOp.weakNodeListener(listener, node)); |
| nodeListener = listener; |
| } |
| } |
| } |
| |
| void showOpeningStatus(String fmtMessage) { |
| JFrame mainWin = (JFrame) WindowManager.getDefault().getMainWindow(); |
| |
| // set wait cursor |
| mainWin.getGlassPane().setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR)); |
| mainWin.getGlassPane().setVisible(true); |
| |
| // set status text like "Opening form: ..." |
| StatusDisplayer.getDefault().setStatusText( |
| FormUtils.getFormattedBundleString( |
| fmtMessage, // NOI18N |
| new Object[] { formDataObject.getFormFile().getName() })); |
| javax.swing.RepaintManager.currentManager(mainWin).paintDirtyRegions(); |
| } |
| |
| void hideOpeningStatus() { |
| // clear wait cursor |
| JFrame mainWin = (JFrame) WindowManager.getDefault().getMainWindow(); |
| mainWin.getGlassPane().setVisible(false); |
| mainWin.getGlassPane().setCursor(null); |
| |
| StatusDisplayer.getDefault().setStatusText(""); // NOI18N |
| } |
| |
| private void addStatusListener(FileSystem fs) { |
| FileStatusListener fsl = fsToStatusListener.get(fs); |
| if (fsl == null) { |
| fsl = new FileStatusListener() { |
| @Override |
| public void annotationChanged(FileStatusEvent ev) { |
| synchronized (opened) { |
| Iterator<FormEditorSupport> iter = opened.iterator(); |
| while (iter.hasNext()) { |
| FormEditorSupport fes = iter.next(); |
| if (ev.hasChanged(fes.getFormDataObject().getPrimaryFile()) |
| || ev.hasChanged(fes.getFormDataObject().getFormFile())) { |
| fes.updateMVTCDisplayName(); |
| } |
| } |
| } |
| } |
| }; |
| fs.addFileStatusListener(fsl); |
| fsToStatusListener.put(fs, fsl); |
| } // else do nothing - the listener is already added |
| } |
| |
| private static void detachStatusListeners() { |
| Iterator iter = fsToStatusListener.entrySet().iterator(); |
| while (iter.hasNext()) { |
| Map.Entry entry = (Map.Entry)iter.next(); |
| FileSystem fs = (FileSystem)entry.getKey(); |
| FileStatusListener fsl = (FileStatusListener)entry.getValue(); |
| fs.removeFileStatusListener(fsl); |
| } |
| fsToStatusListener.clear(); |
| } |
| |
| void selectJavaEditor(){ |
| MultiViewHandler handler = MultiViews.findMultiViewHandler(multiviewTC); |
| if (handler != null) { |
| handler.requestActive(handler.getPerspectives()[JAVA_ELEMENT_INDEX]); |
| } |
| } |
| |
| @Override |
| protected boolean asynchronousOpen() { |
| return false; |
| } |
| |
| @Override |
| public void openSource() { |
| open(); |
| } |
| |
| @Override |
| public void openDesign() { |
| if (EventQueue.isDispatchThread()) { |
| openFormEditor(true); |
| } else { |
| EventQueue.invokeLater(new Runnable() { |
| @Override |
| public void run() { |
| openFormEditor(true); |
| } |
| }); |
| } |
| } |
| |
| /** Overriden from JavaEditor - opens editor and ensures it is selected |
| * in the multiview. |
| */ |
| @Override |
| public void open() { |
| if (EventQueue.isDispatchThread()) { |
| openInAWT(); |
| } else { |
| EventQueue.invokeLater(new Runnable() { |
| @Override |
| public void run() { |
| openInAWT(); |
| } |
| }); |
| } |
| } |
| |
| private void openInAWT() { |
| if (!formDataObject.isValid()) { |
| return; |
| } |
| if (Boolean.TRUE.equals(formDataObject.getPrimaryFile().getAttribute("nonEditableTemplate"))) { // NOI18N |
| String pattern = FormUtils.getBundleString("MSG_NonEditableTemplate"); // NOI18N |
| String message = MessageFormat.format(pattern, new Object[] {formDataObject.getNodeDelegate().getName()}); |
| DialogDisplayer.getDefault().notify(new NotifyDescriptor.Message(message)); |
| return; |
| } |
| elementToOpen = JAVA_ELEMENT_INDEX; |
| super.open(); |
| |
| // This method must be executed in AWT thread because |
| // otherwise multiview is opened in AWT using invokeLater |
| // and we don't have multiviewTC correctly set |
| MultiViewHandler handler = MultiViews.findMultiViewHandler(multiviewTC); |
| if (handler != null) { |
| handler.requestActive(handler.getPerspectives()[JAVA_ELEMENT_INDEX]); |
| // will continue in loadOpeningForm |
| } |
| } |
| |
| /** Overriden from JavaEditor - opens editor at given position and ensures |
| * it is selected in the multiview. |
| * |
| * @param pos position |
| */ |
| public void openAt(PositionRef pos) { |
| elementToOpen = JAVA_ELEMENT_INDEX; |
| openCloneableTopComponent(); |
| |
| MultiViewHandler handler = MultiViews.findMultiViewHandler(multiviewTC); |
| handler.requestActive(handler.getPerspectives()[JAVA_ELEMENT_INDEX]); |
| |
| openAt(pos, -1).getComponent().requestActive(); |
| } |
| |
| @Override |
| public void openAt(Position pos) { |
| openAt(createPositionRef(pos.getOffset(), Position.Bias.Forward)); |
| } |
| |
| boolean startFormLoading() { |
| if (!formEditor.prepareLoading()) { |
| // report errors and switch to Source tab - later because now in the |
| // middle of switching to Design (error dialog would run event queue |
| // and process waiting tasks too soon, e.g. closing - bug 223487) |
| EventQueue.invokeLater(new Runnable() { |
| @Override |
| public void run() { |
| if (formEditor != null) { // not closed yet |
| reportErrors(); |
| selectJavaEditor(); |
| } |
| } |
| }); |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Callback from multiview (FormDesignerTC), requiring to load form whose |
| * designer is just being opened. |
| * @return true if successfully loaded |
| */ |
| boolean loadOpeningForm() { |
| showOpeningStatus("FMT_OpeningForm"); // NOI18N |
| |
| postCreationUpdate1(); |
| |
| boolean success = formEditor.loadFormData(); |
| |
| postCreationUpdate2(); |
| |
| hideOpeningStatus(); |
| |
| reportErrors(); // report errors during loading, fatal or non-fatal |
| |
| if (!success) { // loading failed - don't keep empty designer opened |
| selectJavaEditor(); |
| } |
| |
| return success; |
| } |
| |
| /** Public method for loading form data from file. Does not open the |
| * source editor and designer, does not report errors and does not throw |
| * any exceptions. Runs in AWT event dispatch thread, returns after the |
| * form is loaded (even if not called from AWT thread). |
| * @return whether the form is loaded (true also if it already was) |
| */ |
| public boolean loadForm() { |
| return getFormEditor(true).loadForm(); |
| } |
| |
| /** @return true if the form is opened, false otherwise */ |
| public boolean isOpened() { |
| return (formEditor != null) && formEditor.isFormLoaded(); |
| } |
| |
| private boolean saving; // workaround for bug 75225 |
| |
| /** Save the document in this thread and start reparsing it. |
| * @exception IOException on I/O error |
| */ |
| @Override |
| public void saveDocument() throws IOException { |
| IOException ioEx = null; |
| try { |
| if (formEditor != null) { |
| formEditor.saveFormData(); |
| } |
| saving = true; // workaround for bug 75225 |
| super.saveDocument(); |
| } |
| catch (PersistenceException ex) { |
| Throwable t = ex.getOriginalException(); |
| if (t instanceof IOException) |
| ioEx = (IOException) t; |
| else { |
| ioEx = new IOException("Cannot save the form"); // NOI18N |
| ErrorManager.getDefault().annotate(ioEx, t != null ? t : ex); |
| } |
| } |
| finally { |
| saving = false; // workaround for bug 75225 |
| } |
| if (formEditor != null) { |
| formEditor.reportSavingErrors(); // TODO can't just throw IOException? |
| } |
| |
| if (ioEx != null) |
| throw ioEx; |
| } |
| |
| public void saveSourceOnly() throws IOException { |
| try { |
| saving = true; // workaround for bug 75225 |
| super.saveDocument(); |
| } finally { |
| saving = false; // workaround for bug 75225 |
| } |
| } |
| |
| /** |
| * Reports errors occurred during loading or saving the form. |
| */ |
| private void reportErrors() { |
| if (!formEditor.isFormLoaded()) { |
| formEditor.reportLoadingErrors(null); // fatal error, no options |
| } else { |
| // The form was loaded with some non-fatal errors - some data |
| // was not loaded - show a warning about possible data loss. |
| // The dialog is shown later to let the designer opening complete. |
| JButton viewButton = new JButton(); |
| Mnemonics.setLocalizedText(viewButton, FormUtils.getBundleString("CTL_ViewOnly")); // NOI18N |
| JButton editButton = new JButton(); |
| Mnemonics.setLocalizedText(editButton, FormUtils.getBundleString("CTL_AllowEditing")); // NOI18N |
| final Object[] options = new Object[] { viewButton, editButton, |
| NotifyDescriptor.CANCEL_OPTION }; |
| final DialogDescriptor dd = formEditor.reportLoadingErrors(options); |
| if (dd != null) { |
| java.awt.EventQueue.invokeLater(new Runnable() { |
| @Override |
| public void run() { |
| if (formEditor != null && !formEditor.isFormLoaded()) { |
| return; // quite unlikely, but the form could be closed meanwhile (#164444) |
| } |
| Dialog dialog = DialogDisplayer.getDefault().createDialog(dd); |
| // hack: adjust focus so it is not on the Show Exceptions button |
| if (dialog instanceof JDialog) { |
| ((JDialog)dialog).getContentPane().requestFocus(); |
| } |
| dialog.setVisible(true); |
| dialog.dispose(); |
| |
| Object ret = dd.getValue(); |
| if (ret == options[0]) { // View Only |
| formEditor.setFormReadOnly(); |
| updateMVTCDisplayName(); |
| } else if (ret == options[1]) { // Allow Editing |
| formEditor.destroyInvalidComponents(); |
| } else { // close form, switch to source editor |
| closeFormEditor(); |
| } |
| } |
| }); |
| } |
| } |
| } |
| |
| // ------------ |
| // other interface methods |
| |
| /** @return data object representing the form */ |
| public final FormDataObject getFormDataObject() { |
| return formDataObject; |
| } |
| |
| public FormModel getFormModel() { |
| FormEditor fe = getFormEditor(); |
| return (fe == null) ? null : fe.getFormModel(); |
| } |
| |
| public FormEditor getFormEditor() { |
| return getFormEditor(false); |
| } |
| |
| FormEditor getFormEditor(boolean initialize) { |
| if ((formEditor == null) && initialize) { |
| formEditor = new FormEditor(formDataObject, this); |
| } |
| return formEditor; |
| } |
| |
| private FormDesignerTC getFormDesignerTC() { |
| if (multiviewTC == null) { |
| return null; |
| } |
| return (FormDesignerTC) multiviewTC.getClientProperty("formDesigner"); // NOI18N |
| } |
| |
| /** Marks the form as modified if it's not yet. Used if changes made |
| * in form data don't affect the java source file (generated code). */ |
| @Override |
| public void markModified() { |
| if (formEditor != null && formEditor.isFormLoaded() && !formDataObject.isModified()) { |
| notifyModified(); |
| } |
| } |
| |
| @Override |
| protected UndoRedo.Manager createUndoRedoManager() { |
| editorUndoManager = super.createUndoRedoManager(); |
| return editorUndoManager; |
| } |
| |
| @Override |
| public void discardEditorUndoableEdits() { |
| if (editorUndoManager != null) |
| editorUndoManager.discardAllEdits(); |
| } |
| |
| // ----------- |
| // closing/reloading |
| |
| @Override |
| public void reloadForm() { |
| if (canClose()) |
| reloadDocument(); |
| } |
| |
| @Override |
| protected org.openide.util.Task reloadDocument() { |
| if (multiviewTC == null) |
| return super.reloadDocument(); |
| |
| org.openide.util.Task docLoadTask = super.reloadDocument(); |
| |
| if (saving) // workaround for bug 75225 |
| return docLoadTask; |
| |
| java.awt.EventQueue.invokeLater(new Runnable() { |
| @Override |
| public void run() { |
| FormDesignerTC designerTC = getFormDesignerTC(); |
| if (designerTC != null) { |
| formEditor.closeForm(); |
| designerTC.resetDesigner(true); // will trigger loading |
| } |
| } |
| }); |
| |
| return docLoadTask; |
| } |
| |
| /** |
| * Reload the form if opened. It always loads the form, no matter whether on |
| * Source or Design tabs. That's different from standard reload task that |
| * won't load the form if currently not in Design. |
| */ |
| public FormEditor reloadFormEditor() { |
| if (!isOpened()) { |
| return null; |
| } |
| FormDesignerTC designerTC = getFormDesignerTC(); |
| formEditor.closeForm(); |
| boolean success = formEditor.loadForm(); |
| if (designerTC != null) { |
| if (success) { |
| designerTC.resetDesigner(true); |
| } else { |
| closeFormEditor(); |
| } |
| } |
| reportErrors(); |
| return formEditor; |
| } |
| |
| /** |
| * Closes the form editor without closing the document in editor. The editor |
| * is switched to Source tab, later clicking on Design tab will load the |
| * form again. |
| */ |
| public void closeFormEditor() { |
| if (isOpened()) { |
| final FormDesignerTC designerTC = getFormDesignerTC(); |
| formEditor.closeForm(); |
| Runnable run = new Runnable() { |
| @Override |
| public void run() { |
| if (designerTC != null) { |
| designerTC.resetDesigner(false); |
| } |
| selectJavaEditor(); |
| } |
| }; |
| if (EventQueue.isDispatchThread()) { |
| run.run(); |
| } else { |
| try { |
| java.awt.EventQueue.invokeAndWait(run); |
| } catch (Exception ex) { |
| ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, ex); |
| } |
| } |
| } |
| } |
| |
| @Override |
| protected void notifyClosed() { |
| opened.remove(this); |
| if (opened.isEmpty()) { |
| detachTopComponentsListener(); |
| detachStatusListeners(); |
| } |
| |
| super.notifyClosed(); // close java editor |
| if (formEditor != null) { |
| formEditor.closeForm(); |
| formEditor = null; |
| } |
| nodeListener = null; |
| multiviewTC = null; |
| guardedProvider = null; |
| guardedEditor = null; |
| elementToOpen = JAVA_ELEMENT_INDEX; |
| } |
| |
| private void multiViewClosed(CloneableTopComponent mvtc) { |
| Enumeration en = mvtc.getReference().getComponents(); |
| boolean isLast = !en.hasMoreElements(); |
| if (multiviewTC == mvtc) { |
| multiviewTC = null; |
| FormDesignerTC designerTC = null; |
| // Find another multiviewTC, possibly with loaded formDesigner |
| while (en.hasMoreElements()) { |
| multiviewTC = (CloneableTopComponent)en.nextElement(); |
| designerTC = getFormDesignerTC(); |
| if (designerTC != null) { |
| break; |
| } |
| } |
| if (!isLast && (designerTC == null)) { |
| // Only Java elements are opened in the remaining clones |
| if (formEditor != null) { |
| formEditor.closeForm(); |
| formEditor = null; |
| } |
| } |
| } |
| |
| if (isLast) // last view of this form closed |
| notifyClosed(); |
| } |
| |
| @Override |
| protected boolean notifyModified () { |
| boolean alreadyModified = isModified(); |
| boolean retVal = super.notifyModified(); |
| |
| if (retVal) { // java source modification |
| addSaveCookie(); |
| } |
| |
| if (!alreadyModified) { |
| FileObject formFile = formDataObject.getFormFile(); |
| if (!formFile.canWrite()) { // Issue 74092 |
| FileLock lock = null; |
| try { |
| lock = formFile.lock(); |
| } catch (UserQuestionException uqex) { |
| NotifyDescriptor nd = new NotifyDescriptor.Confirmation( |
| uqex.getLocalizedMessage(), |
| FormUtils.getBundleString("TITLE_UserQuestion"), // NOI18N |
| NotifyDescriptor.YES_NO_OPTION); |
| DialogDisplayer.getDefault().notify(nd); |
| if (NotifyDescriptor.YES_OPTION.equals(nd.getValue())) { |
| try { |
| uqex.confirmed(); |
| EventQueue.invokeLater(new Runnable() { |
| @Override |
| public void run() { |
| reloadForm(); |
| } |
| }); |
| } catch (IOException ioex) { |
| ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, ioex); |
| } |
| } |
| } catch (IOException ex) { |
| ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, ex); |
| } finally { |
| if (lock != null) { |
| lock.releaseLock(); |
| } |
| } |
| } |
| updateMVTCDisplayName(); |
| } |
| return retVal; |
| } |
| |
| @Override |
| protected void notifyUnmodified () { |
| super.notifyUnmodified(); |
| // java source modification |
| removeSaveCookie(); |
| updateMVTCDisplayName(); |
| } |
| |
| private static void attachTopComponentsListener() { |
| if (topcompsListener != null) |
| return; |
| |
| topcompsListener = new PropertyChangeListener() { |
| @Override |
| public void propertyChange(PropertyChangeEvent ev) { |
| if (TopComponent.Registry.PROP_OPENED.equals( |
| ev.getPropertyName())) |
| { // set of opened TopComponents has changed - hasn't some |
| // of our views been closed? |
| Set oldSet = (Set) ev.getOldValue(); |
| Set newSet = (Set) ev.getNewValue(); |
| if (newSet.size() < oldSet.size()) { |
| Iterator it = oldSet.iterator(); |
| while (it.hasNext()) { |
| Object o = it.next(); |
| if (!newSet.contains(o)) { |
| if (o instanceof CloneableTopComponent) { |
| CloneableTopComponent closedTC = (CloneableTopComponent) o; |
| if (getSelectedElementType(closedTC) != -1) { // it is our multiview |
| FormEditorSupport fes = getFormEditor(closedTC); |
| if (fes != null) { |
| fes.multiViewClosed(closedTC); |
| } |
| } |
| } |
| } |
| } |
| } |
| TopComponent active = TopComponent.getRegistry().getActivated(); |
| if (active!=null && getSelectedElementType(active) != -1) { // it is our multiview |
| FormEditorSupport fes = getFormEditor(active); |
| if (fes != null) { |
| fes.updateMVTCDisplayName(); |
| } |
| } |
| } |
| } |
| }; |
| |
| TopComponent.getRegistry().addPropertyChangeListener(topcompsListener); |
| } |
| |
| private static void detachTopComponentsListener() { |
| if (topcompsListener != null) { |
| TopComponent.getRegistry() |
| .removePropertyChangeListener(topcompsListener); |
| topcompsListener = null; |
| |
| TopComponentGroup group = WindowManager.getDefault() |
| .findTopComponentGroup("form"); // NOI18N |
| if (group != null) |
| group.close(); |
| } |
| } |
| |
| /** |
| * Additional updates for a newly created form before it gets loaded for the first time. |
| */ |
| private void postCreationUpdate1() { |
| FileObject fob = formDataObject.getPrimaryFile(); |
| Object libName = fob.getAttribute("requiredLibrary"); // NOI18N |
| if (libName != null) { |
| Object className = fob.getAttribute("requiredClass"); // NOI18N |
| if ((className == null) || !ClassPathUtils.isOnClassPath(fob, className.toString())) { |
| try { |
| Library lib = LibraryManager.getDefault().getLibrary((String)libName); |
| ClassPathUtils.updateProject(fob, new ClassSource( |
| (className == null) ? null : className.toString(), |
| new ClassSourceResolver.LibraryEntry(lib)) |
| ); |
| } catch (IOException ioex) { |
| Logger.getLogger(FormEditorSupport.class.getName()).log(Level.INFO, ioex.getLocalizedMessage(), ioex); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Additional updates for a newly created form, just loaded for the first time. |
| */ |
| private void postCreationUpdate2() { |
| if (formEditor.postCreationUpdate()) { |
| try { |
| checkSuppressWarningsAnnotation(); |
| if (isModified()) { |
| saveDocument(); |
| } |
| } catch (IOException ex) { // unlikely for just created form |
| Logger.getLogger(FormEditorSupport.class.getName()).log(Level.INFO, ex.getLocalizedMessage(), ex); |
| } |
| } |
| } |
| |
| private void checkSuppressWarningsAnnotation() throws IOException { |
| FileObject fo = getFormDataObject().getPrimaryFile(); |
| String sourceLevel = SourceLevelQuery.getSourceLevel(fo); |
| boolean invalidSL = (sourceLevel != null) && ("1.5".compareTo(sourceLevel) > 0); // NOI18N |
| ClassPath cp = ClassPath.getClassPath(fo, ClassPath.BOOT); |
| if (invalidSL || cp.findResource("java/lang/SuppressWarnings.class") == null) { // NOI18N |
| // The project's bootclasspath doesn't contain SuppressWarnings class. |
| // So, remove this annotation from initComponents() method. |
| final String foName = fo.getName(); |
| JavaSource js = JavaSource.forFileObject(fo); |
| final int[] positions = new int[] {-1,-1}; |
| js.runModificationTask(new CancellableTask<WorkingCopy>() { |
| @Override |
| public void cancel() { |
| } |
| @Override |
| public void run(WorkingCopy wcopy) throws Exception { |
| wcopy.toPhase(JavaSource.Phase.RESOLVED); |
| |
| ClassTree clazz = null; |
| CompilationUnitTree cu = wcopy.getCompilationUnit(); |
| for (Tree tree : cu.getTypeDecls()) { |
| if (TreeUtilities.CLASS_TREE_KINDS.contains(tree.getKind())) { |
| ClassTree cand = (ClassTree)tree; |
| if (foName.equals(cand.getSimpleName().toString())) { |
| clazz = cand; |
| } |
| } |
| } |
| if (clazz == null) return; |
| |
| for (Tree tree : clazz.getMembers()) { |
| if (tree.getKind() == Tree.Kind.METHOD) { |
| MethodTree method = (MethodTree)tree; |
| if ("initComponents".equals(method.getName().toString()) // NOI18N |
| && (method.getParameters().isEmpty())) { |
| ModifiersTree modifiers = method.getModifiers(); |
| for (AnnotationTree annotation : modifiers.getAnnotations()) { |
| if (annotation.getAnnotationType().toString().contains("SuppressWarnings")) { // NOI18N |
| SourcePositions sp = wcopy.getTrees().getSourcePositions(); |
| positions[0] = (int)sp.getStartPosition(cu, annotation); |
| positions[1] = (int)sp.getEndPosition(cu, annotation); |
| // We cannot use the following code because |
| // part of the modifier is in guarded block |
| //ModifiersTree newModifiers = wcopy.getTreeMaker().removeModifiersAnnotation(method.getModifiers(), annotation); |
| //wcopy.rewrite(modifiers, newModifiers); |
| } |
| } |
| } |
| } |
| } |
| |
| } |
| }).commit(); |
| if (positions[0] != -1) { |
| try { |
| getFormDataObject().getFormEditorSupport().getDocument().remove(positions[0], positions[1]-positions[0]); |
| } catch (BadLocationException blex) { |
| Logger.getLogger(FormEditor.class.getName()).log(Level.INFO, blex.getLocalizedMessage(), blex); |
| } |
| } |
| } |
| } |
| |
| // ------- |
| // multiview & java editor |
| |
| @Override |
| protected CloneableEditorSupport.Pane createPane() { |
| if (!formDataObject.isValid()) { |
| return super.createPane(); // Issue 110249 |
| } |
| |
| CloneableTopComponent mvtc = MultiViews.createCloneableMultiView("text/x-form", getDataObject()); |
| |
| // #45665 - dock into editor mode if possible.. |
| Mode editorMode = WindowManager.getDefault().findMode(CloneableEditorSupport.EDITOR_MODE); |
| if (editorMode != null) { |
| editorMode.dockInto(mvtc); |
| } |
| return (CloneableEditorSupport.Pane)mvtc; |
| } |
| |
| private static boolean readOnly(FormDataObject formDataObject) { |
| if (!formDataObject.getPrimaryFile().canWrite()) { |
| return true; |
| } |
| TopComponent active = TopComponent.getRegistry().getActivated(); |
| if (active != null && getSelectedElementType(active) == FORM_ELEMENT_INDEX) { |
| FormEditorSupport fes = (FormEditorSupport)formDataObject.getFormEditorSupport(); |
| if (fes != null) { |
| FormModel fm = fes.getFormModel(); |
| if (fm != null) { |
| return fm.isReadOnly(); |
| } |
| } |
| } |
| return false; |
| } |
| |
| private static String getMVTCToolTipText(FormDataObject formDataObject) { |
| return DataEditorSupport.toolTip(formDataObject.getPrimaryFile(), formDataObject.isModified(), readOnly(formDataObject)); |
| } |
| |
| /** |
| * Returns display name of the multiview top component. |
| * The first item of the array is normal display name, |
| * the second item of the array is HTML display name. |
| * |
| * @param formDataObject form data object representing the multiview tc. |
| * @return display names of the MVTC. The second item can be <code>null</code>. |
| */ |
| private static String[] getMVTCDisplayName(FormDataObject formDataObject) { |
| Node node = formDataObject.getNodeDelegate(); |
| String title = node.getDisplayName(); |
| String htmlTitle = node.getHtmlDisplayName(); |
| if (htmlTitle == null) { |
| try { |
| htmlTitle = XMLUtil.toElementContent(title); |
| } catch (CharConversionException x) { |
| htmlTitle = "???"; |
| } |
| } |
| FormEditorSupport fes = (FormEditorSupport)formDataObject.getFormEditorSupport(); |
| if (fes != null) { |
| FormDesignerTC designerTC = fes.getFormDesignerTC(); |
| if (designerTC != null && designerTC.isShowing()) { |
| FormModel fm = fes.getFormModel(); |
| if (fm != null) { |
| FormDesigner fd = FormEditor.getFormDesigner(fes.getFormModel()); |
| if (fd != null && fd.getFormModel() != null |
| && !fd.isTopRADComponent() && fd.getTopDesignComponent() != null) { |
| title = FormUtils.getFormattedBundleString( |
| "FMT_FormTitleWithContainerName", // NOI18N |
| new Object[] {title, fd.getTopDesignComponent().getName()}); |
| htmlTitle = FormUtils.getFormattedBundleString( |
| "FMT_FormTitleWithContainerName", // NOI18N |
| new Object[] {htmlTitle, fd.getTopDesignComponent().getName()}); |
| } |
| } |
| } |
| } |
| boolean modified = formDataObject.isModified(); |
| boolean readOnly = readOnly(formDataObject); |
| return new String[] { |
| DataEditorSupport.annotateName(title, false, modified, readOnly), |
| DataEditorSupport.annotateName(htmlTitle, true, modified, readOnly) |
| }; |
| } |
| |
| @Override |
| protected String messageName() { |
| String[] titles = getMVTCDisplayName(formDataObject); |
| return titles[0]; |
| } |
| |
| @Override |
| protected String messageHtmlName() { |
| String[] titles = getMVTCDisplayName(formDataObject); |
| return titles[1]; |
| } |
| |
| /** Updates title (display name) of all multiviews for given form. Replans |
| * to event queue thread if necessary. */ |
| void updateMVTCDisplayName() { |
| if (java.awt.EventQueue.isDispatchThread()) { |
| updateMVTCDisplayNameInAWT(); |
| } else { |
| java.awt.EventQueue.invokeLater(new Runnable() { |
| @Override |
| public void run() { |
| updateMVTCDisplayNameInAWT(); |
| } |
| }); |
| } |
| } |
| |
| private void updateMVTCDisplayNameInAWT() { |
| if ((multiviewTC == null) || (!formDataObject.isValid())) // Issue 67544 |
| return; |
| |
| String[] titles = getMVTCDisplayName(formDataObject); |
| Enumeration en = multiviewTC.getReference().getComponents(); |
| while (en.hasMoreElements()) { |
| TopComponent tc = (TopComponent) en.nextElement(); |
| tc.setDisplayName(titles[0]); |
| tc.setHtmlDisplayName(titles[1]); |
| } |
| } |
| |
| /** Updates tooltip of all multiviews for given form. Replans to even queue |
| * thread if necessary. */ |
| void updateMVTCToolTipText() { |
| if (java.awt.EventQueue.isDispatchThread()) { |
| if (multiviewTC == null) |
| return; |
| |
| String tooltip = getMVTCToolTipText(formDataObject); |
| Enumeration en = multiviewTC.getReference().getComponents(); |
| while (en.hasMoreElements()) { |
| TopComponent tc = (TopComponent) en.nextElement(); |
| tc.setToolTipText(tooltip); |
| } |
| } |
| else { |
| java.awt.EventQueue.invokeLater(new Runnable() { |
| @Override |
| public void run() { |
| if (multiviewTC == null) |
| return; |
| |
| String tooltip = getMVTCToolTipText(formDataObject); |
| Enumeration en = multiviewTC.getReference().getComponents(); |
| while (en.hasMoreElements()) { |
| TopComponent tc = (TopComponent) en.nextElement(); |
| tc.setToolTipText(tooltip); |
| } |
| } |
| }); |
| } |
| } |
| |
| @Messages({ |
| "MSG_MODIFIED=File {0} is modified. Save?" |
| }) |
| final CloseOperationState canCloseElement(TopComponent tc) { |
| // if this is not the last cloned java editor component, closing is OK |
| if (!FormEditorSupport.isLastView(tc)) { |
| return CloseOperationState.STATE_OK; |
| } |
| |
| if (!isModified()) { |
| return CloseOperationState.STATE_OK; |
| } |
| |
| AbstractAction save = new AbstractAction() { |
| @Override |
| public void actionPerformed(ActionEvent e) { |
| try { |
| saveDocument(); |
| } catch (IOException ex) { |
| Exceptions.printStackTrace(ex); |
| } |
| } |
| }; |
| save.putValue(Action.LONG_DESCRIPTION, Bundle.MSG_MODIFIED( |
| getDataObject().getPrimaryFile().getNameExt() |
| )); |
| |
| // return a placeholder state - to be sure our CloseHandler is called |
| return MultiViewFactory.createUnsafeCloseState( |
| "ID_FORM_CLOSING", // NOI18N |
| save, |
| MultiViewFactory.NOOP_CLOSE_ACTION); |
| } |
| |
| static boolean isLastView(TopComponent tc) { |
| if (!(tc instanceof CloneableTopComponent)) |
| return false; |
| |
| boolean oneOrLess = true; |
| Enumeration en = ((CloneableTopComponent)tc).getReference().getComponents(); |
| if (en.hasMoreElements()) { |
| en.nextElement(); |
| if (en.hasMoreElements()) |
| oneOrLess = false; |
| } |
| return oneOrLess; |
| } |
| |
| /** This is called by the multiview elements whenever they are created |
| * (and given a observer knowing their multiview TopComponent). It is |
| * important during deserialization and cloning the multiview - i.e. during |
| * the operations we have no control over. But anytime a multiview is |
| * created, this method gets called. |
| */ |
| void setTopComponent(TopComponent topComp) { |
| multiviewTC = (CloneableTopComponent)topComp; |
| String[] titles = getMVTCDisplayName(formDataObject); |
| multiviewTC.setDisplayName(titles[0]); |
| multiviewTC.setHtmlDisplayName(titles[1]); |
| multiviewTC.setToolTipText(getMVTCToolTipText(formDataObject)); |
| opened.add(this); |
| registerNodeListener(); |
| attachTopComponentsListener(); |
| try { |
| addStatusListener(formDataObject.getPrimaryFile().getFileSystem()); |
| } catch (FileStateInvalidException fsiex) { |
| fsiex.printStackTrace(); |
| } |
| } |
| |
| public static FormEditorSupport getFormEditor(TopComponent tc) { |
| Object dobj = tc.getLookup().lookup(DataObject.class); |
| FormEditorSupport fes = null; |
| if (dobj instanceof FormDataObject) { |
| FormDataObject formDataObject = (FormDataObject)dobj; |
| fes = (FormEditorSupport)formDataObject.getFormEditorSupport(); |
| } |
| return fes; |
| } |
| |
| @Override |
| public boolean isJavaEditorDisplayed() { |
| boolean showing = false; |
| if (EventQueue.isDispatchThread()) { // issue 91715 |
| JEditorPane[] jeditPane = getOpenedPanes(); |
| if (jeditPane != null) { |
| for (int i=0; i<jeditPane.length; i++) { |
| if (showing = jeditPane[i].isShowing()) { |
| break; |
| } |
| } |
| } |
| } |
| return showing; |
| } |
| |
| /** |
| * Called before regenerating initComponents guarded section to obtain the |
| * actual state of the editor fold for the generated code. Needed for the case |
| * the user expanded it manually to expand it again after recreating the fold |
| * for the new content. |
| * @param offset the start offset of the initComponents section |
| * @return true if the fold is collapsed, false if expanded |
| */ |
| @Override |
| public Boolean getFoldState(int offset) { |
| if (EventQueue.isDispatchThread()) { |
| JEditorPane[] panes = getOpenedPanes(); |
| if (panes != null && panes.length > 0) { |
| FoldHierarchy hierarchy = FoldHierarchy.get(panes[0]); |
| if (hierarchy != null) { |
| try { |
| hierarchy.lock(); |
| Fold fold = FoldUtilities.findNearestFold(hierarchy, offset); |
| if (fold != null) { |
| return fold.isCollapsed(); |
| } |
| } finally { |
| hierarchy.unlock(); |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Called after setting new content to the initComponents section to restore |
| * the remembered state of the fold. Setting the text creates a new fold that |
| * is initially collapsed, we may want to expand it (if the user expanded it |
| * manually in the editor before). |
| * @param collapse |
| * @param startOffset |
| * @param endOffset |
| */ |
| @Override |
| public void restoreFoldState(boolean collapse, int startOffset, int endOffset) { |
| if (collapse) { |
| return; // the fold will be initially collapsed |
| } |
| JEditorPane[] panes = getOpenedPanes(); |
| if (panes != null && panes.length > 0) { |
| FoldHierarchy hierarchy = FoldHierarchy.get(panes[0]); |
| if (hierarchy != null) { |
| try { |
| hierarchy.lock(); |
| Fold fold = FoldUtilities.findCollapsedFold(hierarchy, startOffset, endOffset); |
| if (fold != null) { |
| hierarchy.expand(fold); |
| } else { |
| // in fact we don't really know when the new fold will appear |
| // in the hierarchy, it happens somehow asynchronously |
| if (foldHierarchyListener == null) { |
| foldHierarchyListener = new FoldHierarchyListener(); |
| } else { |
| hierarchy.removeFoldHierarchyListener(foldHierarchyListener); |
| } |
| hierarchy.addFoldHierarchyListener(foldHierarchyListener); |
| foldHierarchyListener.setOffsets(startOffset, endOffset); |
| } |
| } finally { |
| hierarchy.unlock(); |
| } |
| } |
| } |
| } |
| |
| private static class FoldHierarchyListener implements org.netbeans.api.editor.fold.FoldHierarchyListener { |
| private int startOffset = -1; |
| private int endOffset; |
| |
| private void setOffsets(int startOffset, int endOffset) { |
| this.startOffset = startOffset; |
| this.endOffset = endOffset; |
| } |
| |
| @Override |
| public void foldHierarchyChanged(FoldHierarchyEvent evt) { |
| if (startOffset >= 0 |
| && evt.getAddedFoldCount() > 0 |
| && evt.getAffectedStartOffset() < endOffset && evt.getAffectedEndOffset() > startOffset |
| && evt.getSource() instanceof FoldHierarchy) { |
| // here we should have the fold for the new initComponents code added |
| FoldHierarchy hierarchy = (FoldHierarchy) evt.getSource(); |
| Fold fold = FoldUtilities.findCollapsedFold(hierarchy, startOffset, endOffset); |
| if (fold != null) { |
| startOffset = -1; // ignore any futher events |
| hierarchy.expand(fold); |
| } |
| } |
| } |
| } |
| |
| private static Boolean groupVisible = null; |
| |
| static void checkFormGroupVisibility() { |
| // when active TopComponent changes, check if we should open or close |
| // the form editor group of windows (Inspector, Palette, Properties) |
| WindowManager wm = WindowManager.getDefault(); |
| final TopComponentGroup group = wm.findTopComponentGroup("form"); // NOI18N |
| if (group == null) |
| return; // group not found (should not happen) |
| |
| boolean designerSelected = false; |
| Iterator it = wm.getModes().iterator(); |
| while (it.hasNext()) { |
| Mode mode = (Mode) it.next(); |
| TopComponent selected = mode.getSelectedTopComponent(); |
| if (getSelectedElementType(selected) == FORM_ELEMENT_INDEX) { |
| designerSelected = true; |
| break; |
| } |
| } |
| |
| if (designerSelected && !Boolean.TRUE.equals(groupVisible)) { |
| // Bug 116008: calling group.open() first time may cause hiding the |
| // FormDesigner (some winsys multiview initialization mess), calling |
| // this method again and hiding the group. By setting the groupVisible |
| // to false we make the re-entrant call effectively do nothing. |
| groupVisible = Boolean.FALSE; |
| group.open(); |
| groupVisible = Boolean.TRUE; |
| final TopComponentGroup paletteGroup = wm.findTopComponentGroup( "commonpalette" ); // NOI18N |
| if( null != paletteGroup ) { |
| paletteGroup.open(); |
| } |
| } |
| else if (!designerSelected && !Boolean.FALSE.equals(groupVisible)) { |
| group.close(); |
| groupVisible = Boolean.FALSE; |
| } |
| } |
| |
| /** @return 0 if java editor in form editor multiview is selected |
| * 1 if form designer in form editor multiview is selected |
| * -1 if the given TopComponent is not form editor multiview |
| */ |
| static int getSelectedElementType(TopComponent tc) { |
| if (tc != null) { |
| MultiViewHandler handler = MultiViews.findMultiViewHandler(tc); |
| if (handler != null) { |
| String prefId = handler.getSelectedPerspective().preferredID(); |
| if (MV_JAVA_ID.equals(prefId)) |
| return JAVA_ELEMENT_INDEX; // 0 |
| if (MV_FORM_ID.equals(prefId)) |
| return FORM_ELEMENT_INDEX; // 1 |
| } |
| } |
| return -1; |
| } |
| |
| @Override |
| public Object getJavaContext() { |
| return null; // nothing else than FileObject is needed in NB |
| } |
| |
| @Override |
| public int getCodeIndentSize() { |
| CodeStyle cs = CodeStyle.getDefault(getFormDataObject().getPrimaryFile()); |
| return cs != null ? cs.getIndentSize() : 4; |
| } |
| |
| @Override |
| public boolean getCodeBraceOnNewLine() { |
| CodeStyle cs = CodeStyle.getDefault(getFormDataObject().getPrimaryFile()); |
| return cs != null ? cs.getMethodDeclBracePlacement() != CodeStyle.BracePlacement.SAME_LINE : false; |
| } |
| |
| public SimpleSection getVariablesSection() { |
| return getGuardedSectionManager().findSimpleSection(SECTION_VARIABLES); |
| } |
| |
| public SimpleSection getInitComponentSection() { |
| return getGuardedSectionManager().findSimpleSection(SECTION_INIT_COMPONENTS); |
| } |
| |
| @Override |
| public GuardedSectionManager getGuardedSectionManager() { |
| try { |
| StyledDocument doc = null; |
| try { |
| doc = openDocument(); |
| } catch (UserQuestionException uqex) { // Issue 143655 |
| Object retVal = DialogDisplayer.getDefault().notify( |
| new NotifyDescriptor.Confirmation(uqex.getLocalizedMessage(), |
| NotifyDescriptor.YES_NO_OPTION)); |
| if (NotifyDescriptor.YES_OPTION == retVal) { |
| uqex.confirmed(); |
| doc = openDocument(); |
| } |
| } |
| if (doc == null) { |
| // Issue 143655 - opening of big file canceled |
| EventQueue.invokeLater(new Runnable() { |
| @Override |
| public void run() { |
| close(); |
| } |
| }); |
| return null; |
| } else { |
| return GuardedSectionManager.getInstance(doc); |
| } |
| } catch (IOException ex) { |
| throw new IllegalStateException("cannot open document", ex); // NOI18N |
| } |
| } |
| |
| @Override |
| public boolean canGenerateNBMnemonicsCode() { |
| FileObject srcFile = getFormDataObject().getPrimaryFile(); |
| return isNBMProject(srcFile) |
| || ClassPathUtils.checkUserClass("org.openide.awt.Mnemonics", srcFile); // NOI18N |
| } |
| |
| private static boolean isNBMProject(FileObject srcFile) { |
| // hack: checking project impl. class name, is there a better way? |
| Project p = FileOwnerQuery.getOwner(srcFile); |
| return p != null && p.getClass().getName().startsWith("org.netbeans.modules.apisupport.") // NOI18N |
| && p.getClass().getName().endsWith("Project"); // NOI18N |
| } |
| |
| private static final class FormGEditor implements GuardedEditorSupport { |
| |
| StyledDocument doc = null; |
| |
| @Override |
| public StyledDocument getDocument() { |
| return doc; |
| } |
| } |
| |
| private FormGEditor guardedEditor; |
| private GuardedSectionsProvider guardedProvider; |
| |
| @Override |
| protected void loadFromStreamToKit(StyledDocument doc, InputStream stream, EditorKit kit) throws IOException, BadLocationException { |
| if (guardedEditor == null) { |
| guardedEditor = new FormGEditor(); |
| GuardedSectionsFactory gFactory = GuardedSectionsFactory.find(((DataEditorSupport.Env) env).getMimeType()); |
| if (gFactory != null) { |
| guardedProvider = gFactory.create(guardedEditor); |
| } |
| } |
| |
| if (guardedProvider != null) { |
| guardedEditor.doc = doc; |
| Charset c = FileEncodingQuery.getEncoding(this.getDataObject().getPrimaryFile()); |
| Reader reader = guardedProvider.createGuardedReader(stream, c); |
| try { |
| kit.read(reader, doc, 0); |
| } finally { |
| reader.close(); |
| } |
| } else { |
| super.loadFromStreamToKit(doc, stream, kit); |
| } |
| } |
| |
| @Override |
| protected void saveFromKitToStream(StyledDocument doc, EditorKit kit, OutputStream stream) throws IOException, BadLocationException { |
| if (guardedProvider != null) { |
| Charset c = FileEncodingQuery.getEncoding(this.getDataObject().getPrimaryFile()); |
| Writer writer = guardedProvider.createGuardedWriter(stream, c); |
| try { |
| kit.write(writer, doc, 0, doc.getLength()); |
| } finally { |
| writer.close(); |
| } |
| } else { |
| super.saveFromKitToStream(doc, kit, stream); |
| } |
| } |
| |
| @MultiViewElement.Registration( |
| displayName="#CTL_SourceTabCaption", |
| iconBase=iconURL, |
| persistenceType=TopComponent.PERSISTENCE_ONLY_OPENED, |
| preferredID=MV_JAVA_ID, |
| mimeType="text/x-form", |
| position=1000 |
| ) |
| public static class JavaMultiViewEditorElement extends MultiViewEditorElement { |
| private static final long serialVersionUID =-3126744316624172415L; |
| |
| private DataObject dataObject; |
| private transient FormEditorSupport javaEditor; |
| private transient MultiViewElementCallback multiViewObserver; |
| |
| public JavaMultiViewEditorElement(Lookup context) { |
| super(context); |
| dataObject = context.lookup(DataObject.class); |
| javaEditor = context.lookup(FormEditorSupport.class); |
| if (javaEditor != null) { |
| javaEditor.prepareDocument(); |
| } |
| } |
| |
| @Override |
| public void setMultiViewCallback(MultiViewElementCallback callback) { |
| multiViewObserver = callback; |
| |
| // needed for deserialization... |
| if (dataObject instanceof FormDataObject) { |
| // this is used (or misused?) to obtain the deserialized |
| // multiview topcomponent and set it to FormEditorSupport |
| FormDataObject formDataObject = (FormDataObject) dataObject; |
| FormEditorSupport fes = (FormEditorSupport)formDataObject.getFormEditorSupport(); |
| if (javaEditor == null) { |
| javaEditor = fes; |
| } |
| fes.setTopComponent(callback.getTopComponent()); |
| } |
| super.setMultiViewCallback(callback); |
| } |
| |
| @Override |
| public void componentShowing() { |
| super.componentShowing(); |
| if (dataObject instanceof FormDataObject) { |
| FormDataObject formDO = (FormDataObject) dataObject; |
| FormEditorSupport fe = (FormEditorSupport)formDO.getFormEditorSupport(); |
| if (fe != null) { |
| FormModel model = fe.getFormModel(); |
| if (model != null) { |
| CodeGenerator codeGen = FormEditor.getCodeGenerator(model); |
| if (codeGen != null) { |
| codeGen.regenerateCode(); |
| } |
| } |
| } |
| } |
| } |
| |
| @Override |
| public CloseOperationState canCloseElement() { |
| if (javaEditor == null) { |
| return CloseOperationState.STATE_OK; |
| } |
| return javaEditor.canCloseElement(multiViewObserver.getTopComponent()); |
| } |
| } |
| |
| private static final class Environment extends DataEditorSupport.Env { |
| |
| private static final long serialVersionUID = -1; |
| |
| public Environment(DataObject obj) { |
| super(obj); |
| } |
| |
| @Override |
| protected FileObject getFile() { |
| return this.getDataObject().getPrimaryFile(); |
| } |
| |
| @Override |
| protected FileLock takeLock() throws java.io.IOException { |
| return ((FormDataObject) getDataObject()).getPrimaryEntry().takeLock(); |
| } |
| |
| @Override |
| public CloneableOpenSupport findCloneableOpenSupport() { |
| return this.getDataObject().getCookie(FormEditorSupport.class); |
| } |
| |
| } |
| |
| private final SaveCookie saveCookie = new SaveCookie() { |
| @Override |
| public void save() throws java.io.IOException { |
| if (formEditor == null) { // not saving form, only java |
| doSave(false); // don't need to be in event dispatch thread (#102986) |
| } else if (EventQueue.isDispatchThread()) { |
| doSave(true); |
| } else { |
| try { |
| EventQueue.invokeAndWait(new Runnable() { |
| @Override |
| public void run() { |
| doSave(true); |
| } |
| }); |
| } catch (InterruptedException ex) { |
| Logger.getLogger(FormEditorSupport.class.getName()).log(Level.INFO, "", ex); // NOI18N |
| } catch (InvocationTargetException ex) { |
| if (ex.getCause() instanceof RuntimeException) { |
| throw (RuntimeException) ex.getCause(); |
| } |
| Logger.getLogger(FormEditorSupport.class.getName()).log(Level.INFO, "", ex); // NOI18N |
| } |
| } |
| } |
| |
| private void doSave(boolean bothJavaAndForm) { |
| try { |
| if (bothJavaAndForm) { |
| saveDocument(); |
| } else { |
| saveSourceOnly(); |
| } |
| } catch (IOException ex) { |
| Logger.getLogger(FormEditorSupport.class.getName()).log(Level.INFO, "", ex); // NOI18N |
| } |
| } |
| }; |
| |
| private final CookieSet cookies; |
| |
| public void addSaveCookie() { |
| DataObject javaData = this.getDataObject(); |
| if (javaData.getCookie(SaveCookie.class) == null) { |
| cookies.add(saveCookie); |
| javaData.setModified(true); |
| } |
| } |
| |
| public void removeSaveCookie() { |
| DataObject javaData = this.getDataObject(); |
| if (javaData.getCookie(SaveCookie.class) != null) { |
| cookies.remove(saveCookie); |
| javaData.setModified(false); |
| } |
| } |
| |
| } |
