Index: loaders/src/org/openide/text/SimpleES.java =================================================================== RCS file: loaders/src/org/openide/text/SimpleES.java diff -N loaders/src/org/openide/text/SimpleES.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ loaders/src/org/openide/text/SimpleES.java 10 May 2004 06:40:42 -0000 @@ -0,0 +1,145 @@ +/* + * Sun Public License Notice + * + * The contents of this file are subject to the Sun Public License + * Version 1.0 (the "License"). You may not use this file except in + * compliance with the License. A copy of the License is available at + * http://www.sun.com/ + * + * The Original Code is NetBeans. The Initial Developer of the Original + * Code is Sun Microsystems, Inc. Portions Copyright 1997-2004 Sun + * Microsystems, Inc. All Rights Reserved. + */ + + +package org.openide.text; + + +import java.io.IOException; + +import org.openide.cookies.CloseCookie; +import org.openide.cookies.EditCookie; +import org.openide.cookies.EditorCookie; +import org.openide.cookies.OpenCookie; +import org.openide.cookies.PrintCookie; +import org.openide.cookies.SaveCookie; +import org.openide.filesystems.FileObject; +import org.openide.filesystems.FileLock; +import org.openide.loaders.DataObject; +import org.openide.loaders.MultiDataObject; +import org.openide.nodes.CookieSet; +import org.openide.nodes.Node.Cookie; +import org.openide.text.DataEditorSupport; +import org.openide.windows.CloneableOpenSupport; + + +/** + * Basic editor support. + * + * @author Jaroslav Tulach + */ +final class SimpleES extends DataEditorSupport +implements OpenCookie, EditCookie, EditorCookie.Observable, PrintCookie, CloseCookie { + /** SaveCookie for this support instance. The cookie is adding/removing + * data object's cookie set depending on if modification flag was set/unset. */ + private final SaveCookie saveCookie = new SaveCookie() { + /** Implements SaveCookie interface. */ + public void save() throws IOException { + SimpleES.this.saveDocument(); + } + }; + + private CookieSet set; + + /** Constructor. + * @param obj data object to work on + * @param set set to add/remove save cookie from + */ + SimpleES (DataObject obj, MultiDataObject.Entry entry, CookieSet set) { + super(obj, new Environment(obj, entry)); + this.set = set; + setMIMEType("text/plain"); // NOI18N + } + + /** + * Overrides superclass method. Adds adding of save cookie if the document has been marked modified. + * @return true if the environment accepted being marked as modified + * or false if it has refused and the document should remain unmodified + */ + protected boolean notifyModified () { + if (!super.notifyModified()) + return false; + + addSaveCookie(); + + return true; + } + + /** Overrides superclass method. Adds removing of save cookie. */ + protected void notifyUnmodified () { + super.notifyUnmodified(); + + removeSaveCookie(); + } + + /** Helper method. Adds save cookie to the data object. */ + private void addSaveCookie() { + DataObject obj = getDataObject(); + + // Adds save cookie to the data object. + if(obj.getCookie(SaveCookie.class) == null) { + set.add(saveCookie); + obj.setModified(true); + } + } + + /** Helper method. Removes save cookie from the data object. */ + private void removeSaveCookie() { + DataObject obj = getDataObject(); + + // Remove save cookie from the data object. + Cookie cookie = obj.getCookie(SaveCookie.class); + + if(cookie != null && cookie.equals(saveCookie)) { + set.remove(saveCookie); + obj.setModified(false); + } + } + + + /** Nested class. Environment for this support. Extends + * DataEditorSupport.Env abstract class. + */ + + private static class Environment extends DataEditorSupport.Env { + private static final long serialVersionUID = 5451434321155443431L; + + private MultiDataObject.Entry entry; + + /** Constructor. */ + public Environment(DataObject obj, MultiDataObject.Entry entry) { + super(obj); + this.entry = entry; + } + + + /** Implements abstract superclass method. */ + protected FileObject getFile() { + return entry.getFile(); + } + + /** Implements abstract superclass method.*/ + protected FileLock takeLock() throws IOException { + return entry.takeLock(); + } + + /** + * Overrides superclass method. + * @return text editor support (instance of enclosing class) + */ + public CloneableOpenSupport findCloneableOpenSupport() { + return (SimpleES)getDataObject().getCookie(SimpleES.class); + } + } // End of nested Environment class. + +} Index: loaders/src/org/openide/text/DataEditorSupport.java =================================================================== RCS file: /cvs/openide/loaders/src/org/openide/text/DataEditorSupport.java,v retrieving revision 1.15 diff -u -3 -p -r1.15 DataEditorSupport.java --- loaders/src/org/openide/text/DataEditorSupport.java 30 Apr 2004 13:56:35 -0000 1.15 +++ loaders/src/org/openide/text/DataEditorSupport.java 10 May 2004 06:40:42 -0000 @@ -57,6 +57,19 @@ public class DataEditorSupport extends C this.obj = obj; } + /** Factory method to create simple DataEditorSupport for a given + * entry of a given DataObject. + * @param obj the data object + * @param entry the entry to read and write from + * @param set cookie set to add remove additional cookies + * @return a subclass of DataEditorSupport that implements at least + * OpenCookie, EditCookie, EditorCookie.Observable, PrintCookie, CloseCookie + * @since XXX + */ + public static DataEditorSupport create (DataObject obj, MultiDataObject.Entry entry, org.openide.nodes.CookieSet set) { + return new SimpleES (obj, entry, set); + } + /** Getter of the data object that this support is associated with. * @return data object passed in constructor */ Index: test/unit/src/org/openide/text/SimpleDESTest.java =================================================================== RCS file: test/unit/src/org/openide/text/SimpleDESTest.java diff -N test/unit/src/org/openide/text/SimpleDESTest.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ test/unit/src/org/openide/text/SimpleDESTest.java 10 May 2004 06:40:42 -0000 @@ -0,0 +1,161 @@ +/* + * Sun Public License Notice + * + * The contents of this file are subject to the Sun Public License + * Version 1.0 (the "License"). You may not use this file except in + * compliance with the License. A copy of the License is available at + * http://www.sun.com/ + * + * The Original Code is NetBeans. The Initial Developer of the Original + * Code is Sun Microsystems, Inc. Portions Copyright 1997-2002 Sun + * Microsystems, Inc. All Rights Reserved. + */ + +package org.openide.text; + +import java.io.PrintStream; +import javax.swing.Action; +import junit.textui.TestRunner; +import org.netbeans.junit.*; +import org.openide.DialogDescriptor; +import org.openide.cookies.EditorCookie; +import org.openide.cookies.OpenCookie; +import org.openide.filesystems.*; +import org.openide.loaders.DataObject; +import org.openide.util.actions.SystemAction; + +/** DefaultDataObject is supposed to have open operation that shows the text + * editor or invokes a dialog with questions. + * + * @author Jaroslav Tulach + */ +public final class SimpleDESTest extends NbTestCase { + + private FileSystem lfs; + private DataObject obj; + + /** Creates a new instance of DefaultSettingsContextTest */ + public SimpleDESTest(String name) { + super(name); + } + + public static void main(String[] args) { + TestRunner.run(new NbTestSuite(SimpleDESTest.class)); + System.exit (0); + } + + protected void setUp() throws java.lang.Exception { + System.setProperty("org.openide.util.Lookup", "org.openide.text.SimpleDESTest$Lkp"); + super.setUp(); + + String fsstruct [] = new String [] { + "AA/a.test" + }; + + TestUtilHid.destroyLocalFileSystem(getName()); + lfs = TestUtilHid.createLocalFileSystem(getName(), fsstruct); + + FileObject fo = lfs.findResource("AA/a.test"); + assertNotNull("file not found", fo); + obj = DataObject.find(fo); + + assertEquals ("The right class", obj.getClass (), SO.class); + } + + protected void tearDown() throws java.lang.Exception { + super.tearDown(); + } + + public void testHasEditorCookieForResonableContentOfFiles () throws Exception { + EditorCookie c = tryToOpen ( + "Ahoj Jardo," + + "how are you" + + "\t\n\rBye" + ); + assertNotNull (c); + + assertEquals ( + "Next questions results in the same cookie", + c, + obj.getCookie(EditorCookie.class) + ); + assertEquals ( + "Print cookie is provided", + c, + obj.getCookie(org.openide.cookies.PrintCookie.class) + ); + assertEquals ( + "CloseCookie as well", + c, + obj.getCookie(org.openide.cookies.CloseCookie.class) + ); + + OpenCookie open = (OpenCookie)obj.getCookie (OpenCookie.class); + open.open (); + + javax.swing.text.Document d = c.getDocument(); + assertNotNull (d); + + d.insertString(0, "Kuk", null); + + assertNotNull ( + "Now there is a save cookie", + obj.getCookie (org.openide.cookies.SaveCookie.class) + ); + } + + private EditorCookie tryToOpen (String content) throws Exception { + FileObject fo = obj.getPrimaryFile(); + FileLock lock = fo.lock(); + PrintStream os = new PrintStream (fo.getOutputStream(lock)); + os.print (content); + os.close (); + lock.releaseLock(); + + return (EditorCookie)obj.getCookie (EditorCookie.class); + } + + // + // Our fake lookup + // + public static final class Lkp extends org.openide.util.lookup.AbstractLookup { + public Lkp () { + this (new org.openide.util.lookup.InstanceContent ()); + } + + private Lkp (org.openide.util.lookup.InstanceContent ic) { + super (ic); + ic.add (new DLP ()); + } + } + + private static final class SL extends org.openide.loaders.UniFileLoader { + public SL () { + super (SO.class.getName ()); + getExtensions().addExtension("test"); + } + protected org.openide.loaders.MultiDataObject createMultiObject(FileObject primaryFile) throws org.openide.loaders.DataObjectExistsException, java.io.IOException { + return new SO (primaryFile); + } + } // end of SL + + private static final class SO extends org.openide.loaders.MultiDataObject { + public SO (FileObject fo) throws org.openide.loaders.DataObjectExistsException { + super (fo, (SL)SL.getLoader(SL.class)); + + getCookieSet().add ((org.openide.nodes.Node.Cookie) + DataEditorSupport.create(this, getPrimaryEntry(), getCookieSet ()) + ); + } + } // end of SO + + private static final class DLP extends org.openide.loaders.DataLoaderPool { + protected java.util.Enumeration loaders() { + return java.util.Collections.enumeration( + java.util.Collections.singleton( + SL.getLoader (SL.class) + ) + ); + } + } // end of DataLoaderPool +}