Attachment #113430 for bug #162526

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 162526
Collapse All | Expand All

Lines 63-69 Link Here

(-)a/core.startup/nbproject/project.xml (-1 / +1 lines)
63	<build-prerequisite/>	63	<build-prerequisite/>
64	<compile-dependency/>	64	<compile-dependency/>
65	<run-dependency>	65	<run-dependency>
66	<specification-version>7.35</specification-version>	66	<specification-version>7.55</specification-version>
67	</run-dependency>	67	</run-dependency>
68	</dependency>	68	</dependency>
69	<dependency>	69	<dependency>




        }
    }

    private class WritableRemover implements Callable<Void> {
        private String name;
        public WritableRemover( String name ) {
            this.name = name;
        }
        
        @Override public Void call() throws IOException {
            FileObject fo = findResource( name );
            if( null != fo ) {
                fo.delete();




import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.Callable;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
import org.netbeans.Module;
import org.netbeans.core.startup.Main;
import org.netbeans.junit.NbTestCase;
import org.openide.filesystems.FileLock;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;


        
        existingFile.setAttribute( "myAttribute", "myAttributeValue" );
        
        assertFalse("removeWritables does not work for file attributes", FileUtil.getConfigFile("foo").canRevert());
    }






import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.Callable;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;

        
        File writableFile = new File( new File( configDir, "foo"), "newFile.ext" );
        assertTrue( writableFile.exists() );

        assertTrue(newFile.canRevert());
        newFile.revert();
        assertNotNull( writablesRemover );
        assertTrue( writablesRemover instanceof Callable );
        
        ((Callable)writablesRemover).call();
        
        assertFalse( "local file removed", writableFile.exists() );
        assertNull( "FileObject does not exist", FileUtil.getConfigFile( "foo/newFile.ext" ) );

        
        File maskFile = new File( new File( configDir, "foo"), "test1_hidden" );
        assertTrue( maskFile.exists() );

        FileObject newFile = FileUtil.getConfigFile("foo");
        assertTrue(newFile.canRevert());
        newFile.revert();
        assertTrue( writablesRemover instanceof Callable );
        
        ((Callable)writablesRemover).call();
        
        assertFalse( "local file removed", maskFile.exists() );
        assertNotNull( "FileObject exists again", FileUtil.getConfigFile( "foo/test1" ) );

        File maskFile = new File( new File( configDir, "foo"), "test1_hidden" );
        assertTrue( maskFile.exists() );
        
        FileObject newFile = FileUtil.getConfigFile("foo");
        assertTrue(newFile.canRevert());
        newFile.revert();
        assertTrue( writablesRemover instanceof Callable );
        
        ((Callable)writablesRemover).call();
        
        assertFalse( "local file removed", maskFile.exists() );
        assertNotNull( "FileObject exists again", FileUtil.getConfigFile( "foo/test1" ) );

Lines 125-131 Link Here

(-)a/core.windows/nbproject/project.xml (-1 / +1 lines)
125	<build-prerequisite/>	125	<build-prerequisite/>
126	<compile-dependency/>	126	<compile-dependency/>
127	<run-dependency>	127	<run-dependency>
128	<specification-version>7.19</specification-version>	128	<specification-version>7.55</specification-version>
129	</run-dependency>	129	</run-dependency>
130	</dependency>	130	</dependency>
131	<dependency>	131	<dependency>




package org.netbeans.core.windows.view.ui.toolbars;

import java.awt.event.ActionEvent;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.AbstractAction;

    public void actionPerformed(ActionEvent e) {
        String name = ToolbarPool.getDefault().getConfiguration();
        FileObject fo = FileUtil.getConfigFile( "Toolbars" ); //NOI18N
        try {
            fo.revert();
        } catch (IOException ex) {
            Logger.getLogger(ResetToolbarsAction.class.getName()).log( Level.FINE, null, ex );
            } catch (Exception ex) {
                Logger.getLogger(ResetToolbarsAction.class.getName()).log( Level.FINE, null, ex );
            }
        }
        ToolbarPool.getDefault().waitFinished();
        ToolbarPool.getDefault().setConfiguration(name);

Lines 167-173 Link Here

(-)a/editor/nbproject/project.xml (-1 / +1 lines)
167	<build-prerequisite/>	167	<build-prerequisite/>
168	<compile-dependency/>	168	<compile-dependency/>
169	<run-dependency>	169	<run-dependency>
170	<specification-version>7.19</specification-version>	170	<specification-version>7.55</specification-version>
171	</run-dependency>	171	</run-dependency>
172	</dependency>	172	</dependency>
173	<dependency>	173	<dependency>

Lines 95-101 Link Here

(-)a/favorites/nbproject/project.xml (-1 / +1 lines)
95	<build-prerequisite/>	95	<build-prerequisite/>
96	<compile-dependency/>	96	<compile-dependency/>
97	<run-dependency>	97	<run-dependency>
98	<specification-version>7.19</specification-version>	98	<specification-version>7.55</specification-version>
99	</run-dependency>	99	</run-dependency>
100	</dependency>	100	</dependency>
101	<dependency>	101	<dependency>




import org.openide.explorer.ExplorerUtils;
import org.openide.explorer.view.BeanTreeView;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileStateInvalidException;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.LocalFileSystem;
import org.openide.filesystems.MultiFileSystem;
import org.openide.loaders.DataFilter;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;

import org.openide.nodes.NodeReorderEvent;
import org.openide.nodes.PropertySupport;
import org.openide.nodes.Sheet;
import org.openide.util.Exceptions;
import org.openide.util.HelpCtx;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;

import org.openide.util.actions.NodeAction;
import org.openide.util.actions.SystemAction;
import org.openide.util.lookup.AbstractLookup;
import org.openide.util.lookup.InstanceContent;
import org.openide.util.lookup.ProxyLookup;
import org.openide.windows.TopComponent;


        String name = n.getFileName();
        String displayName = n.getDisplayName();
        FileObject fo = n.getLookup().lookup(FileObject.class);
        RenameTemplatePanel editPanel = new RenameTemplatePanel(fo.canRevert());
        editPanel.setFileName(name);
        editPanel.setFileDisplayName(displayName);
        String title = org.openide.util.NbBundle.getMessage(TemplatesPanel.class, "RenameTemplatePanel.title.text");

        }
    }

    /** Test if the file physically exists on disk and thus was created by user and can be renamed. */
    private static boolean isUserFile(FileObject fo) {
        String path = fo.getPath();
        // Find if this path is on non-local filesystems
        FileSystem fs;
        try {
            fs = fo.getFileSystem();
        } catch (FileStateInvalidException ex) {
            return false;
        }
        return !isOnNonLocalFS(fs, path);
    }

    private static boolean isOnNonLocalFS(FileSystem fs, String path) {
        if (fs instanceof MultiFileSystem) {
            MultiFileSystem mfs = (MultiFileSystem) fs;
            try {
                java.lang.reflect.Method getDelegatesMethod;
                getDelegatesMethod = MultiFileSystem.class.getDeclaredMethod("getDelegates"); // NOI18N
                getDelegatesMethod.setAccessible(true);
                FileSystem[] delegates = (FileSystem[]) getDelegatesMethod.invoke(mfs);
                for (FileSystem fsd : delegates) {
                    if (isOnNonLocalFS(fsd, path)) {
                        return true;
                    }
                }
            } catch (NoSuchMethodException ex) {
                Exceptions.printStackTrace(ex);
            } catch (SecurityException ex) {
                Exceptions.printStackTrace(ex);
            } catch (IllegalAccessException ex) {
                Exceptions.printStackTrace(ex);
            } catch (IllegalArgumentException ex) {
                Exceptions.printStackTrace(ex);
            } catch (InvocationTargetException ex) {
                Exceptions.printStackTrace(ex);
            }
            return false;
        } else {
            if (fs instanceof LocalFileSystem) {
                return false; // is local FS
            } else {
                return fs.findResource(path) != null;
            }
        }
    }
    
    // action
    private static class AddAction extends NodeAction {
        protected void performAction (Node[] activatedNodes) {

Lines 115-121 Link Here

(-)a/ide.ergonomics/nbproject/project.xml (-1 / +1 lines)
115	<build-prerequisite/>	115	<build-prerequisite/>
116	<compile-dependency/>	116	<compile-dependency/>
117	<run-dependency>	117	<run-dependency>
118	<specification-version>7.19</specification-version>	118	<specification-version>7.55</specification-version>
119	</run-dependency>	119	</run-dependency>
120	</dependency>	120	</dependency>
121	<dependency>	121	<dependency>




import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.Callable;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

                first = false;
            }
            LOG.info(cnb);
            module.revert();
            if (clean instanceof Callable) {
                ((Callable)clean).call();
            }
        }
    }


Lines 182-188 Link Here

(-)a/java.j2seplatform/nbproject/project.xml (-1 / +1 lines)
182	<build-prerequisite/>	182	<build-prerequisite/>
183	<compile-dependency/>	183	<compile-dependency/>
184	<run-dependency>	184	<run-dependency>
185	<specification-version>7.19</specification-version>	185	<specification-version>7.55</specification-version>
186	</run-dependency>	186	</run-dependency>
187	</dependency>	187	</dependency>
188	<dependency>	188	<dependency>




 */
package org.netbeans.modules.java.j2seplatform;

import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.openide.cookies.InstanceCookie;

                }
                if (!valid) {
                    Logger.getLogger("global").log(Level.WARNING,"default_platform.xml is broken, regenerating.");
                    defaultPlatform.revert();
                    if (attr instanceof Callable) {
                        ((Callable)attr).call ();
                    }
                }
            } catch (IOException e) {
                Exceptions.printStackTrace(e);
            }
        }

Lines 157-163 Link Here

(-)a/o.apache.tools.ant.module/nbproject/project.xml (-1 / +1 lines)
157	<build-prerequisite/>	157	<build-prerequisite/>
158	<compile-dependency/>	158	<compile-dependency/>
159	<run-dependency>	159	<run-dependency>
160	<specification-version>7.19</specification-version>	160	<specification-version>7.55</specification-version>
161	</run-dependency>	161	</run-dependency>
162	</dependency>	162	</dependency>
163	<dependency>	163	<dependency>




import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.KeyStroke;

        delete(shortcut);
    }
    private static void delete(FileObject file) throws IOException { // cf. #162526
        if (file.canRevert()) {
            file.revert();
            try {
                ((Callable<?>) delete).call();
            } catch (java.lang.Exception x) {
                throw (IOException) new IOException("Could not delete " + file + ": " + x.toString()).initCause(x);
            }
        } else {
            throw new IOException("Could not delete " + file);
        }




        <apidef name="filesystems">Filesystems API</apidef>
    </apidefs>
    <changes>
        <change id="FileObject.revert">
            <api name="filesystems"/>
            <summary>Introduced <code>FileObject.revert</code></summary>
            <version major="7" minor="55"/>
            <date year="2011" month="11" day="29"/>
            <author login="jglick"/>
            <compatibility addition="yes">
                <p>
                    The previous SPI has been kept. Only a more convenient API has been introduced,
                    so it is no longer necessary for callers to look for a <code>removeWritables</code> attribute.
                </p>
            </compatibility>
            <description>
                <p>
                    Added <code>revert</code> and <code>canRevert</code> to <code>FileObject</code>.
                </p>
            </description>
            <class package="org.openide.filesystems" name="FileObject"/>
            <issue number="162526"/>
        </change>
        <change id="FileObject.getMIMEType...">
            <api name="filesystems"/>
            <summary>FileObject.getMIMEType(String... withinMIMETypes)</summary>

Lines 2-6 Link Here

(-)a/openide.filesystems/manifest.mf (-1 / +1 lines)
2	OpenIDE-Module: org.openide.filesystems	2	OpenIDE-Module: org.openide.filesystems
3	OpenIDE-Module-Localizing-Bundle: org/openide/filesystems/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/openide/filesystems/Bundle.properties
4	OpenIDE-Module-Layer: org/openide/filesystems/resources/layer.xml	4	OpenIDE-Module-Layer: org/openide/filesystems/resources/layer.xml
5	OpenIDE-Module-Specification-Version: 7.54	5	OpenIDE-Module-Specification-Version: 7.55
6		6




import java.util.LinkedList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.concurrent.Callable;
import java.util.logging.Level;
import org.openide.util.Enumerations;
import org.openide.util.UserQuestionException;

        return true;
    }

    static final String REMOVE_WRITABLES_ATTR = "removeWritables";

    /**
     * Checks whether this file can be reverted to a pristine state.
     * @return whether {@link #revert} might do something
     * @since 7.55
     */
    public final boolean canRevert() {
        return getAttribute(REMOVE_WRITABLES_ATTR) instanceof Callable<?>;
    }

    /**
     * Revert this file to a pristine state.
     * Generally only meaningful for files on the system filesystem (layers + user directory):
     * if the file is defined in a layer but modified in the user directory, it is reset;
     * if it is defined only in the user directory, it is deleted.
     * If {@link #canRevert} is false, does nothing.
     * Note that while content can be reset, it may not be possible to reset attributes.
     * <p>Implementors: for historical reasons this method checks {@link #getAttribute}
     * for a special attribute named {@code removeWritables} which must be of type
     * {@link Callable Callable<Void>}. If present, the file is considered modified.
     * @since 7.55
     */
    public final void revert() throws IOException {
        Object v = getAttribute(REMOVE_WRITABLES_ATTR);
        if (v instanceof Callable<?>) {
            try {
                ((Callable<?>) v).call();
            } catch (IOException x) {
                throw x;
            } catch (Exception x) {
                throw new IOException(x);
            }
        }
    }

    /** Should check for external modifications. For folders it should reread
    * the content of disk, for data file it should check for the last
    * time the file has been modified.

Lines 792-798 Link Here

(-)a/openide.filesystems/src/org/openide/filesystems/MultiFileObject.java (-1 / +1 lines)
792	}	792	}
793		793
794	/** Special attributes which should not be checked for weight. See RemoveWritablesTest. */	794	/** Special attributes which should not be checked for weight. See RemoveWritablesTest. */
795	private static final Set<String> SPECIAL_ATTR_NAMES = new HashSet<String>(Arrays.asList("removeWritables", WEIGHT_ATTRIBUTE, "java.io.File")); // NOI18N	795	private static final Set<String> SPECIAL_ATTR_NAMES = new HashSet<String>(Arrays.asList(FileObject.REMOVE_WRITABLES_ATTR, WEIGHT_ATTRIBUTE, "java.io.File")); // NOI18N
796	private final Object getAttribute(String attrName, String path) {	796	private final Object getAttribute(String attrName, String path) {
797	// Look for attribute in any file system starting at the front.	797	// Look for attribute in any file system starting at the front.
798	// Additionally, look for attribute in root folder, where	798	// Additionally, look for attribute in root folder, where

Lines 122-128 Link Here

(-)a/openide.loaders/nbproject/project.xml (-1 / +1 lines)
122	<build-prerequisite/>	122	<build-prerequisite/>
123	<compile-dependency/>	123	<compile-dependency/>
124	<run-dependency>	124	<run-dependency>
125	<specification-version>7.52</specification-version>	125	<specification-version>7.55</specification-version>
126	</run-dependency>	126	</run-dependency>
127	</dependency>	127	</dependency>
128	<dependency>	128	<dependency>




import java.beans.PropertyChangeEvent;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.Callable;
import java.util.logging.Level;
import java.util.logging.Logger;


        return cookie;
    }
    private void revertProblematicFile(DataObject dob) {
        try {
            dob.getPrimaryFile().revert();
        } catch (IOException x) {
            err.log(Level.INFO, null, x);
            } catch (Exception x) {
                err.log(Level.INFO, null, x);
            }
        }
    }
    




        </question>
-->
<answer id="exec-component">
    No.
    <code>FileObject</code>s created on XML layer now support a new 
    attribute <code>removeWritables</code> returning an instance of
    <code>Callable</code> which removes the local writable version of the
    given <code>FileObject</code> thus reverting the folder or file to
    its initial state as defined in XML layers. Please note that is <em>not</em>
    possible to reset <code>FileObject</code>'s attributes.
</api>
</answer>



Lines 87-93 Link Here

(-)a/spi.palette/nbproject/project.xml (-1 / +1 lines)
87	<build-prerequisite/>	87	<build-prerequisite/>
88	<compile-dependency/>	88	<compile-dependency/>
89	<run-dependency>	89	<run-dependency>
90	<specification-version>7.19</specification-version>	90	<specification-version>7.55</specification-version>
91	</run-dependency>	91	</run-dependency>
92	</dependency>	92	</dependency>
93	<dependency>	93	<dependency>




import java.io.IOException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.concurrent.Callable;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.*;

            if( null != dob ) {
                FileObject primaryFile = dob.getPrimaryFile();
                if( null != primaryFile && primaryFile.isFolder() ) {
                    try {
                        primaryFile.revert();
                    } catch (IOException ex) {
                        ERR.log(Level.INFO, null, ex);
                        } catch (Exception ex) {
                            ERR.log( Level.INFO, ex.getLocalizedMessage(), ex );
                        }
                    }
                }
            }

Return to bug 162526

Lines 222-234 Link Here

(-)a/core.startup/src/org/netbeans/core/startup/layers/LocalFileSystemEx.java (-2 / +2 lines)
222	}	222	}
223	}	223	}
224		224
225	private class WritableRemover implements Callable {	225	private class WritableRemover implements Callable<Void> {
226	private String name;	226	private String name;
227	public WritableRemover( String name ) {	227	public WritableRemover( String name ) {
228	this.name = name;	228	this.name = name;
229	}	229	}
230		230
231	public Object call() throws Exception {	231	@Override public Void call() throws IOException {
232	FileObject fo = findResource( name );	232	FileObject fo = findResource( name );
233	if( null != fo ) {	233	if( null != fo ) {
234	fo.delete();	234	fo.delete();

Lines 49-55 Link Here

(-)a/openide.loaders/src/org/openide/loaders/FolderInstance.java (-8 / +4 lines)
49	import java.beans.PropertyChangeEvent;	49	import java.beans.PropertyChangeEvent;
50	import java.io.IOException;	50	import java.io.IOException;
51	import java.util.*;	51	import java.util.*;
52	import java.util.concurrent.Callable;
53	import java.util.logging.Level;	52	import java.util.logging.Level;
54	import java.util.logging.Logger;	53	import java.util.logging.Logger;
55		54
Lines 462-474 Link Here
462	return cookie;	461	return cookie;
463	}	462	}
464	private void revertProblematicFile(DataObject dob) {	463	private void revertProblematicFile(DataObject dob) {
465	Object rw = dob.getPrimaryFile().getAttribute("removeWritables"); // NOI18N	464	try {
466	if (rw instanceof Callable) {	465	dob.getPrimaryFile().revert();
467	try {	466	} catch (IOException x) {
468	((Callable<?>) rw).call();	467	err.log(Level.INFO, null, x);
469	} catch (Exception x) {
470	err.log(Level.INFO, null, x);
471	}
472	}	468	}
473	}	469	}
474		470

Lines 50-63 Link Here

(-)a/core.startup/test/unit/src/org/netbeans/core/startup/layers/RemoveWritablesModifiedTest.java (-3 / +1 lines)
50	import java.io.FileOutputStream;	50	import java.io.FileOutputStream;
51	import java.io.IOException;	51	import java.io.IOException;
52	import java.io.InputStream;	52	import java.io.InputStream;
53	import java.util.concurrent.Callable;
54	import java.util.jar.JarEntry;	53	import java.util.jar.JarEntry;
55	import java.util.jar.JarOutputStream;	54	import java.util.jar.JarOutputStream;
56	import java.util.jar.Manifest;	55	import java.util.jar.Manifest;
57	import org.netbeans.Module;	56	import org.netbeans.Module;
58	import org.netbeans.core.startup.Main;	57	import org.netbeans.core.startup.Main;
59	import org.netbeans.junit.NbTestCase;	58	import org.netbeans.junit.NbTestCase;
60	import org.openide.filesystems.FileLock;
61	import org.openide.filesystems.FileObject;	59	import org.openide.filesystems.FileObject;
62	import org.openide.filesystems.FileUtil;	60	import org.openide.filesystems.FileUtil;
63		61
Lines 116-122 Link Here
116		114
117	existingFile.setAttribute( "myAttribute", "myAttributeValue" );	115	existingFile.setAttribute( "myAttribute", "myAttributeValue" );
118		116
119	assertNull( "removeWritables does not work for file attributes", FileUtil.getConfigFile( "foo" ).getAttribute( "removeWritables" ) );	117	assertFalse("removeWritables does not work for file attributes", FileUtil.getConfigFile("foo").canRevert());
120	}	118	}
121		119
122		120

Lines 45-51 Link Here

(-)a/core.windows/src/org/netbeans/core/windows/view/ui/toolbars/ResetToolbarsAction.java (-8 / +5 lines)
45	package org.netbeans.core.windows.view.ui.toolbars;	45	package org.netbeans.core.windows.view.ui.toolbars;
46		46
47	import java.awt.event.ActionEvent;	47	import java.awt.event.ActionEvent;
48	import java.util.concurrent.Callable;	48	import java.io.IOException;
49	import java.util.logging.Level;	49	import java.util.logging.Level;
50	import java.util.logging.Logger;	50	import java.util.logging.Logger;
51	import javax.swing.AbstractAction;	51	import javax.swing.AbstractAction;
Lines 68-80 Link Here
68	public void actionPerformed(ActionEvent e) {	68	public void actionPerformed(ActionEvent e) {
69	String name = ToolbarPool.getDefault().getConfiguration();	69	String name = ToolbarPool.getDefault().getConfiguration();
70	FileObject fo = FileUtil.getConfigFile( "Toolbars" ); //NOI18N	70	FileObject fo = FileUtil.getConfigFile( "Toolbars" ); //NOI18N
71	Object attr = fo.getAttribute( "removeWritables" ); //NOI18N	71	try {
72	if( null != attr && attr instanceof Callable ) {	72	fo.revert();
73	try {	73	} catch (IOException ex) {
74	((Callable)attr).call();	74	Logger.getLogger(ResetToolbarsAction.class.getName()).log( Level.FINE, null, ex );
75	} catch (Exception ex) {
76	Logger.getLogger(ResetToolbarsAction.class.getName()).log( Level.FINE, null, ex );
77	}
78	}	75	}
79	ToolbarPool.getDefault().waitFinished();	76	ToolbarPool.getDefault().waitFinished();
80	ToolbarPool.getDefault().setConfiguration(name);	77	ToolbarPool.getDefault().setConfiguration(name);

Lines 78-84 Link Here

(-)a/editor/src/org/netbeans/modules/editor/EditorModule.java (-3 / +1 lines)
78	import org.netbeans.editor.LocaleSupport;	78	import org.netbeans.editor.LocaleSupport;
79	import org.netbeans.modules.editor.indent.api.Reformat;	79	import org.netbeans.modules.editor.indent.api.Reformat;
80	import org.netbeans.modules.editor.lib.EditorPackageAccessor;	80	import org.netbeans.modules.editor.lib.EditorPackageAccessor;
81	import org.netbeans.modules.editor.lib2.EditorApiPackageAccessor;
82	import org.netbeans.modules.editor.lib2.document.ReadWriteUtils;	81	import org.netbeans.modules.editor.lib2.document.ReadWriteUtils;
83	import org.netbeans.modules.editor.options.AnnotationTypesFolder;	82	import org.netbeans.modules.editor.options.AnnotationTypesFolder;
84	import org.openide.cookies.EditorCookie;	83	import org.openide.cookies.EditorCookie;
Lines 324-331 Link Here
324	@Override public void operationRename(Rename ev) {}	323	@Override public void operationRename(Rename ev) {}
325	@Override public void operationCreateShadow(Copy ev) {}	324	@Override public void operationCreateShadow(Copy ev) {}
326	@Override public void operationCreateFromTemplate(Copy ev) {	325	@Override public void operationCreateFromTemplate(Copy ev) {
327	Object removeWritables = ev.getOriginalDataObject().getPrimaryFile().getAttribute("removeWritables");	326	if (!ev.getOriginalDataObject().getPrimaryFile().canRevert()) {
328	if (removeWritables == null) {
329	// Reformat only files created from original templates.	327	// Reformat only files created from original templates.
330	reformat(ev.getObject());	328	reformat(ev.getObject());
331	}	329	}

Lines 81-91 Link Here

(-)a/favorites/src/org/netbeans/modules/favorites/templates/TemplatesPanel.java (-54 / +1 lines)
81	import org.openide.explorer.ExplorerUtils;	81	import org.openide.explorer.ExplorerUtils;
82	import org.openide.explorer.view.BeanTreeView;	82	import org.openide.explorer.view.BeanTreeView;
83	import org.openide.filesystems.FileObject;	83	import org.openide.filesystems.FileObject;
84	import org.openide.filesystems.FileStateInvalidException;
85	import org.openide.filesystems.FileSystem;
86	import org.openide.filesystems.FileUtil;	84	import org.openide.filesystems.FileUtil;
87	import org.openide.filesystems.LocalFileSystem;
88	import org.openide.filesystems.MultiFileSystem;
89	import org.openide.loaders.DataFilter;	85	import org.openide.loaders.DataFilter;
90	import org.openide.loaders.DataFolder;	86	import org.openide.loaders.DataFolder;
91	import org.openide.loaders.DataObject;	87	import org.openide.loaders.DataObject;
Lines 99-105 Link Here
99	import org.openide.nodes.NodeReorderEvent;	95	import org.openide.nodes.NodeReorderEvent;
100	import org.openide.nodes.PropertySupport;	96	import org.openide.nodes.PropertySupport;
101	import org.openide.nodes.Sheet;	97	import org.openide.nodes.Sheet;
102	import org.openide.util.Exceptions;
103	import org.openide.util.HelpCtx;	98	import org.openide.util.HelpCtx;
104	import org.openide.util.Lookup;	99	import org.openide.util.Lookup;
105	import org.openide.util.NbBundle;	100	import org.openide.util.NbBundle;
Lines 107-113 Link Here
107	import org.openide.util.actions.NodeAction;	102	import org.openide.util.actions.NodeAction;
108	import org.openide.util.actions.SystemAction;	103	import org.openide.util.actions.SystemAction;
109	import org.openide.util.lookup.AbstractLookup;	104	import org.openide.util.lookup.AbstractLookup;
110	import org.openide.util.lookup.InstanceContent;
111	import org.openide.util.lookup.ProxyLookup;	105	import org.openide.util.lookup.ProxyLookup;
112	import org.openide.windows.TopComponent;	106	import org.openide.windows.TopComponent;
113		107
Lines 1188-1194 Link Here
1188	String name = n.getFileName();	1182	String name = n.getFileName();
1189	String displayName = n.getDisplayName();	1183	String displayName = n.getDisplayName();
1190	FileObject fo = n.getLookup().lookup(FileObject.class);	1184	FileObject fo = n.getLookup().lookup(FileObject.class);
1191	RenameTemplatePanel editPanel = new RenameTemplatePanel(isUserFile(fo));	1185	RenameTemplatePanel editPanel = new RenameTemplatePanel(fo.canRevert());
1192	editPanel.setFileName(name);	1186	editPanel.setFileName(name);
1193	editPanel.setFileDisplayName(displayName);	1187	editPanel.setFileDisplayName(displayName);
1194	String title = org.openide.util.NbBundle.getMessage(TemplatesPanel.class, "RenameTemplatePanel.title.text");	1188	String title = org.openide.util.NbBundle.getMessage(TemplatesPanel.class, "RenameTemplatePanel.title.text");
Lines 1208-1260 Link Here
1208	}	1202	}
1209	}	1203	}
1210		1204
1211	/** Test if the file physically exists on disk and thus was created by user and can be renamed. */
1212	private static boolean isUserFile(FileObject fo) {
1213	String path = fo.getPath();
1214	// Find if this path is on non-local filesystems
1215	FileSystem fs;
1216	try {
1217	fs = fo.getFileSystem();
1218	} catch (FileStateInvalidException ex) {
1219	return false;
1220	}
1221	return !isOnNonLocalFS(fs, path);
1222	}
1223
1224	private static boolean isOnNonLocalFS(FileSystem fs, String path) {
1225	if (fs instanceof MultiFileSystem) {
1226	MultiFileSystem mfs = (MultiFileSystem) fs;
1227	try {
1228	java.lang.reflect.Method getDelegatesMethod;
1229	getDelegatesMethod = MultiFileSystem.class.getDeclaredMethod("getDelegates"); // NOI18N
1230	getDelegatesMethod.setAccessible(true);
1231	FileSystem[] delegates = (FileSystem[]) getDelegatesMethod.invoke(mfs);
1232	for (FileSystem fsd : delegates) {
1233	if (isOnNonLocalFS(fsd, path)) {
1234	return true;
1235	}
1236	}
1237	} catch (NoSuchMethodException ex) {
1238	Exceptions.printStackTrace(ex);
1239	} catch (SecurityException ex) {
1240	Exceptions.printStackTrace(ex);
1241	} catch (IllegalAccessException ex) {
1242	Exceptions.printStackTrace(ex);
1243	} catch (IllegalArgumentException ex) {
1244	Exceptions.printStackTrace(ex);
1245	} catch (InvocationTargetException ex) {
1246	Exceptions.printStackTrace(ex);
1247	}
1248	return false;
1249	} else {
1250	if (fs instanceof LocalFileSystem) {
1251	return false; // is local FS
1252	} else {
1253	return fs.findResource(path) != null;
1254	}
1255	}
1256	}
1257
1258	// action	1205	// action
1259	private static class AddAction extends NodeAction {	1206	private static class AddAction extends NodeAction {
1260	protected void performAction (Node[] activatedNodes) {	1207	protected void performAction (Node[] activatedNodes) {

Lines 56-62 Link Here

(-)a/ide.ergonomics/src/org/netbeans/modules/ide/ergonomics/fod/FeatureManager.java (-5 / +1 lines)
56	import java.util.Map;	56	import java.util.Map;
57	import java.util.Set;	57	import java.util.Set;
58	import java.util.TreeSet;	58	import java.util.TreeSet;
59	import java.util.concurrent.Callable;
60	import java.util.logging.Level;	59	import java.util.logging.Level;
61	import java.util.logging.LogRecord;	60	import java.util.logging.LogRecord;
62	import java.util.logging.Logger;	61	import java.util.logging.Logger;
Lines 466-475 Link Here
466	first = false;	465	first = false;
467	}	466	}
468	LOG.info(cnb);	467	LOG.info(cnb);
469	Object clean = module.getAttribute("removeWritables"); // NOI18N	468	module.revert();
470	if (clean instanceof Callable) {
471	((Callable)clean).call();
472	}
473	}	469	}
474	}	470	}
475		471

Lines 43-49 Link Here

(-)a/java.j2seplatform/src/org/netbeans/modules/java/j2seplatform/J2SEPlatformModule.java (-6 / +3 lines)
43	*/	43	*/
44	package org.netbeans.modules.java.j2seplatform;	44	package org.netbeans.modules.java.j2seplatform;
45		45
46	import java.util.concurrent.Callable;	46	import java.io.IOException;
47	import java.util.logging.Level;	47	import java.util.logging.Level;
48	import java.util.logging.Logger;	48	import java.util.logging.Logger;
49	import org.openide.cookies.InstanceCookie;	49	import org.openide.cookies.InstanceCookie;
Lines 92-103 Link Here
92	}	92	}
93	if (!valid) {	93	if (!valid) {
94	Logger.getLogger("global").log(Level.WARNING,"default_platform.xml is broken, regenerating.");	94	Logger.getLogger("global").log(Level.WARNING,"default_platform.xml is broken, regenerating.");
95	Object attr = defaultPlatform.getAttribute("removeWritables"); //NOI18N	95	defaultPlatform.revert();
96	if (attr instanceof Callable) {
97	((Callable)attr).call ();
98	}
99	}	96	}
100	} catch (Exception e) {	97	} catch (IOException e) {
101	Exceptions.printStackTrace(e);	98	Exceptions.printStackTrace(e);
102	}	99	}
103	}	100	}

Lines 52-58 Link Here

(-)a/o.apache.tools.ant.module/src/org/apache/tools/ant/module/wizards/shortcut/ShortcutWizard.java (-8 / +2 lines)
52	import java.util.ArrayList;	52	import java.util.ArrayList;
53	import java.util.Arrays;	53	import java.util.Arrays;
54	import java.util.List;	54	import java.util.List;
55	import java.util.concurrent.Callable;
56	import java.util.logging.Level;	55	import java.util.logging.Level;
57	import java.util.logging.Logger;	56	import java.util.logging.Logger;
58	import javax.swing.KeyStroke;	57	import javax.swing.KeyStroke;
Lines 172-184 Link Here
172	delete(shortcut);	171	delete(shortcut);
173	}	172	}
174	private static void delete(FileObject file) throws IOException { // cf. #162526	173	private static void delete(FileObject file) throws IOException { // cf. #162526
175	Object delete = file.getAttribute("removeWritables"); // NOI18N	174	if (file.canRevert()) {
176	if (delete instanceof Callable) {	175	file.revert();
177	try {
178	((Callable<?>) delete).call();
179	} catch (java.lang.Exception x) {
180	throw (IOException) new IOException("Could not delete " + file + ": " + x.toString()).initCause(x);
181	}
182	} else {	176	} else {
183	throw new IOException("Could not delete " + file);	177	throw new IOException("Could not delete " + file);
184	}	178	}

Lines 49-54 Link Here

(-)a/openide.filesystems/apichanges.xml (+20 lines)
49	<apidef name="filesystems">Filesystems API</apidef>	49	<apidef name="filesystems">Filesystems API</apidef>
50	</apidefs>	50	</apidefs>
51	<changes>	51	<changes>
		52	<change id="FileObject.revert">
		53	<api name="filesystems"/>
		54	<summary>Introduced <code>FileObject.revert</code></summary>
		55	<version major="7" minor="55"/>
		56	<date year="2011" month="11" day="29"/>
		57	<author login="jglick"/>
		58	<compatibility addition="yes">
		59	<p>
		60	The previous SPI has been kept. Only a more convenient API has been introduced,
		61	so it is no longer necessary for callers to look for a <code>removeWritables</code> attribute.
		62	</p>
		63	</compatibility>
		64	<description>
		65	<p>
		66	Added <code>revert</code> and <code>canRevert</code> to <code>FileObject</code>.
		67	</p>
		68	</description>
		69	<class package="org.openide.filesystems" name="FileObject"/>
		70	<issue number="162526"/>
		71	</change>
52	<change id="FileObject.getMIMEType...">	72	<change id="FileObject.getMIMEType...">
53	<api name="filesystems"/>	73	<api name="filesystems"/>
54	<summary>FileObject.getMIMEType(String... withinMIMETypes)</summary>	74	<summary>FileObject.getMIMEType(String... withinMIMETypes)</summary>

Lines 60-65 Link Here

(-)a/openide.filesystems/src/org/openide/filesystems/FileObject.java (+37 lines)
60	import java.util.LinkedList;	60	import java.util.LinkedList;
61	import java.util.List;	61	import java.util.List;
62	import java.util.StringTokenizer;	62	import java.util.StringTokenizer;
		63	import java.util.concurrent.Callable;
63	import java.util.logging.Level;	64	import java.util.logging.Level;
64	import org.openide.util.Enumerations;	65	import org.openide.util.Enumerations;
65	import org.openide.util.UserQuestionException;	66	import org.openide.util.UserQuestionException;
Lines 1058-1063 Link Here
1058	return true;	1059	return true;
1059	}	1060	}
1060		1061
		1062	static final String REMOVE_WRITABLES_ATTR = "removeWritables";
		1063
		1064	/**
		1065	* Checks whether this file can be reverted to a pristine state.
		1066	* @return whether {@link #revert} might do something
		1067	* @since 7.55
		1068	*/
		1069	public final boolean canRevert() {
		1070	return getAttribute(REMOVE_WRITABLES_ATTR) instanceof Callable<?>;
		1071	}
		1072
		1073	/**
		1074	* Revert this file to a pristine state.
		1075	* Generally only meaningful for files on the system filesystem (layers + user directory):
		1076	* if the file is defined in a layer but modified in the user directory, it is reset;
		1077	* if it is defined only in the user directory, it is deleted.
		1078	* If {@link #canRevert} is false, does nothing.
		1079	* Note that while content can be reset, it may not be possible to reset attributes.
		1080	* <p>Implementors: for historical reasons this method checks {@link #getAttribute}
		1081	* for a special attribute named {@code removeWritables} which must be of type
		1082	* {@link Callable Callable<Void>}. If present, the file is considered modified.
		1083	* @since 7.55
		1084	*/
		1085	public final void revert() throws IOException {
		1086	Object v = getAttribute(REMOVE_WRITABLES_ATTR);
		1087	if (v instanceof Callable<?>) {
		1088	try {
		1089	((Callable<?>) v).call();
		1090	} catch (IOException x) {
		1091	throw x;
		1092	} catch (Exception x) {
		1093	throw new IOException(x);
		1094	}
		1095	}
		1096	}
		1097
1061	/** Should check for external modifications. For folders it should reread	1098	/** Should check for external modifications. For folders it should reread
1062	* the content of disk, for data file it should check for the last	1099	* the content of disk, for data file it should check for the last
1063	* time the file has been modified.	1100	* time the file has been modified.

Lines 326-339 Link Here

(-)a/openide.modules/arch.xml (-8 / +1 lines)
326	</question>	326	</question>
327	-->	327	-->
328	<answer id="exec-component">	328	<answer id="exec-component">
329	<api category="devel" group="property" name="RevertFSModifications" type="export">	329	No.
330	<code>FileObject</code>s created on XML layer now support a new
331	attribute <code>removeWritables</code> returning an instance of
332	<code>Callable</code> which removes the local writable version of the
333	given <code>FileObject</code> thus reverting the folder or file to
334	its initial state as defined in XML layers. Please note that is <em>not</em>
335	possible to reset <code>FileObject</code>'s attributes.
336	</api>
337	</answer>	330	</answer>
338		331
339		332

Lines 54-60 Link Here

(-)a/spi.palette/src/org/netbeans/modules/palette/Utils.java (-8 / +4 lines)
54	import java.io.IOException;	54	import java.io.IOException;
55	import java.util.Arrays;	55	import java.util.Arrays;
56	import java.util.Comparator;	56	import java.util.Comparator;
57	import java.util.concurrent.Callable;
58	import java.util.logging.Level;	57	import java.util.logging.Level;
59	import java.util.logging.Logger;	58	import java.util.logging.Logger;
60	import javax.swing.*;	59	import javax.swing.*;
Lines 204-216 Link Here
204	if( null != dob ) {	203	if( null != dob ) {
205	FileObject primaryFile = dob.getPrimaryFile();	204	FileObject primaryFile = dob.getPrimaryFile();
206	if( null != primaryFile && primaryFile.isFolder() ) {	205	if( null != primaryFile && primaryFile.isFolder() ) {
207	final Object cleaner = primaryFile.getAttribute( "removeWritables" ); //NOI18N	206	try {
208	if( null != cleaner && (cleaner instanceof Callable) ) {	207	primaryFile.revert();
209	try {	208	} catch (IOException ex) {
210	((Callable)cleaner).call();	209	ERR.log(Level.INFO, null, ex);
211	} catch (Exception ex) {
212	ERR.log( Level.INFO, ex.getLocalizedMessage(), ex );
213	}
214	}	210	}
215	}	211	}
216	}	212	}