import org.netbeans.modules.masterfs.providers.AnnotationProvider;

        SystemAction[] some = status.getActions (foSet);

        if (some != null) {

            return some;

        }

/*

 *                 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-2005 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.modules.masterfs.providers;

import java.io.IOException;

/** Can provide status and actions for FileObjects. Register it 

 * in META-INF/services/org.netbeans.modules.masterfs.providers.AnnotationProvider

 * file.

 *

 * @author Jaroslav Tulach

 */

public abstract class AnnotationProvider extends Object {

    /** listeners */

    private org.openide.filesystems.FileStatusListener listener;

    /** lock for modification of listeners */

    private static Object LOCK = new Object ();

    /** Annotate the name of a file cluster.

    * @param name the name suggested by default

    * @param files an immutable set of {@link FileObject}s belonging to this filesystem

    * @return the annotated name or null if this provider does not know how to annotate these files

    */

    public abstract String annotateName (String name, java.util.Set files);

    /** Annotate the icon of a file cluster.

     * <p>Please do <em>not</em> modify the original; create a derivative icon image,

     * using a weak-reference cache if necessary.

    * @param icon the icon suggested by default

    * @param iconType an icon type from {@link java.beans.BeanInfo}

    * @param files an immutable set of {@link FileObject}s belonging to this filesystem

    * @return the annotated icon or null if some other provider shall anotate the icon

    */

    public abstract java.awt.Image annotateIcon (java.awt.Image icon, int iconType, java.util.Set files);

    /** Annotate a name such that the returned value contains HTML markup.

     * The return value less the html content should typically be the same 

     * as the return value from <code>annotateName()</code>.  This is used,

     * for example, by VCS filesystems to deëphasize the status information

     * included in the file name by using a light grey font color. 

     * <p>

     * For consistency with <code>Node.getHtmlDisplayName()</code>, 

     * filesystems that proxy other filesystems (and so must implement

     * this interface to supply HTML annotations) should return null if

     * the filesystem they proxy does not provide an implementation of

     * HTMLStatus.

     *

     * @see org.openide.awt.HtmlRenderer

     * @see <a href="@OPENIDE/LOADERS@/org/openide/loaders/DataNode.html#getHtmlDisplayName()"><code>DataNode.getHtmlDisplayName()</code></a>

     * @see org.openide.nodes.Node#getHtmlDisplayName

     **/

    public abstract String annotateNameHtml (String name, java.util.Set files);

    /** Provides actions that should be added to given set of files.

     * @return null or array of actions for these files.

     */

    public abstract javax.swing.Action[] actions (java.util.Set files);

    //

    // Listener support

    //

    /** Registers FileStatusListener to receive events.

    * The implementation registers the listener only when getStatus () is 

    * overriden to return a special value.

    *

    * @param listener The listener to register.

    */

    public final void addFileStatusListener (

        org.openide.filesystems.FileStatusListener listener

    ) throws java.util.TooManyListenersException {

        synchronized (LOCK) {

            if (this.listener != null) {

                throw new java.util.TooManyListenersException ();

            }

            this.listener = listener;

        }

    }

    /** Removes FileStatusListener from the list of listeners.

     *@param listener The listener to remove.

     */

    public final void removeFileStatusListener (

        org.openide.filesystems.FileStatusListener listener

    ) {

        synchronized (LOCK) {

            if (this.listener == listener) {

                this.listener = null;

            }

        }

    }

    /** Notifies all registered listeners about change of status of some files.

    *

    * @param event The event to be fired

    */

    protected final void fireFileStatusChanged(org.openide.filesystems.FileStatusEvent event) {

        org.openide.filesystems.FileStatusListener l;

        synchronized (LOCK) {

            l = this.listener;

        }

        if (l != null) {

            l.annotationChanged (event);

        }

    }    

}

/*

 *                 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-2005 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.modules.masterfs.providers;

import junit.framework.*;

import java.io.IOException;

/** Check the behaviour of masterfs's annation provider.

 *

 * @author Jaroslav Tulach

 */

public class AnnotationProviderTest extends org.netbeans.junit.NbTestCase {

    private AnnoProv a1, a2, a3, a4;

    private org.openide.filesystems.FileSystem fs;

    private org.openide.filesystems.FileObject fo;

    public AnnotationProviderTest (String testName) {

        super (testName);

    }

    static {

        System.setProperty ("org.openide.util.Lookup", "org.netbeans.modules.masterfs.providers.AnnotationProviderTest$Lkp"); // NOI18N

    }

    // TODO add test methods here. The name must begin with 'test'. For example:

    // public void testHello() {}

    protected void setUp () throws java.lang.Exception {

        assertEquals (Lkp.class, org.openide.util.Lookup.getDefault ().getClass ());

        // we need some masterfs fileobject

        fs = org.netbeans.modules.masterfs.MasterFileSystem.settingsFactory (null);

        fo = fs.getRoot ();

        assertEquals (org.netbeans.modules.masterfs.MasterFileSystem.class, fo.getFileSystem ().getClass ());

        a1 = new AnnoProv ();

        a2 = new AnnoProv ();

        a3 = new AnnoProv ();

        a4 = new AnnoProv ();

        Lkp.ic.add (a1);

        Lkp.ic.add (a2);

        Lkp.ic.add (a3);

        Lkp.ic.add (a4);

    }

    protected void tearDown () throws java.lang.Exception {

        Lkp.ic.remove (a1);

        Lkp.ic.remove (a2);

        Lkp.ic.remove (a3);

        Lkp.ic.remove (a4);

    }

    public static junit.framework.Test suite () {

        junit.framework.TestSuite suite = new junit.framework.TestSuite(AnnotationProviderTest.class);

        return suite;

    }

    public void testAnnotateName () {

        a2.returnName = "MyName";

        String r = fs.getStatus ().annotateName ("Kuk", java.util.Collections.singleton (fo));

        assertEquals ("My name returned", a2.returnName, r);

        assertEquals ("Kuk", a1.queriedName);

        assertEquals ("Kuk", a2.queriedName);

        assertNull ("Not queried at all", a3.queriedName);

        assertNull ("Not queried at all", a4.queriedName);

        assertTrue ("fo is the file", a1.filesName.contains (fo));

        assertTrue ("fo is the file", a2.filesName.contains (fo));

        assertNull (a1.filesActions);

        assertNull (a1.filesHtml);

        assertNull (a1.filesIcon);

        assertNull (a2.filesActions);

        assertNull (a2.filesHtml);

        assertNull (a2.filesIcon);

    }

    public void testAnnotateIcon () {

        int t = java.awt.image.BufferedImage.TYPE_BYTE_GRAY;

        java.awt.image.BufferedImage my = new java.awt.image.BufferedImage (10, 10, t);

        java.awt.image.BufferedImage his = new java.awt.image.BufferedImage (20, 20, t);

        a2.returnIcon = his;

        java.awt.Image r = fs.getStatus ().annotateIcon (my, 0, java.util.Collections.singleton (fo));

        assertEquals ("My name returned", his, r);

        assertSame (my, a1.queriedIcon);

        assertSame (my, a2.queriedIcon);

        assertNull ("Not queried at all", a3.queriedIcon);

        assertNull ("Not queried at all", a4.queriedIcon);

        assertNull (a1.filesActions);

        assertNull (a1.filesHtml);

        assertNull (a1.filesName);

        assertNull (a2.filesActions);

        assertNull (a2.filesHtml);

        assertNull (a2.filesName);

    }

    public void testAnnotateNameHtml () {

        a2.returnHtml = "MyName";

        Object o = fs.getStatus ();

        assertTrue ("Must be HtmlStatus", o instanceof org.openide.filesystems.FileSystem.HtmlStatus);

        org.openide.filesystems.FileSystem.HtmlStatus status = (org.openide.filesystems.FileSystem.HtmlStatus)o;

        String r = status.annotateNameHtml ("Kuk", java.util.Collections.singleton (fo));

        assertEquals ("My name returned", a2.returnHtml, r);

        assertEquals ("Kuk", a1.queriedHtml);

        assertEquals ("Kuk", a2.queriedHtml);

        assertNull ("Not queried at all", a3.queriedHtml);

        assertNull ("Not queried at all", a4.queriedHtml);

        assertTrue ("fo is the file", a1.filesHtml.contains (fo));

        assertTrue ("fo is the file", a2.filesHtml.contains (fo));

        assertNull (a1.filesActions);

        assertNull (a1.filesName);

        assertNull (a1.filesIcon);

        assertNull (a2.filesActions);

        assertNull (a2.filesName);

        assertNull (a2.filesIcon);

    }

    public void testActionsWorksOnSystemActionsCorrectly () {

        a2.returnActions = new javax.swing.Action[] {

            org.openide.actions.OpenAction.get (org.openide.actions.OpenAction.class)

        };

        java.util.Set s = java.util.Collections.singleton (fo);

        javax.swing.Action[] actions = fs.getActions (s);

        assertEquals ("Actions has the same size", a2.returnActions.length, actions.length);

        assertEquals ("And that is one", 1, actions.length);

        assertEquals ("First elem is same", a2.returnActions[0], actions[0]);

        assertEquals ("a1 queried", s, a1.filesActions);

        assertEquals ("a2 queried", s, a2.filesActions);

        assertNull ("Not queried at all", a3.filesActions);

        assertNull ("Not queried at all", a4.filesActions);

        assertNull (a1.filesHtml);

        assertNull (a1.filesName);

        assertNull (a1.filesIcon);

        assertNull (a2.filesHtml);

        assertNull (a2.filesName);

        assertNull (a2.filesIcon);

    }

    public void testListeningCapabilities () {

        class L implements org.openide.filesystems.FileStatusListener {

            public org.openide.filesystems.FileStatusEvent ev;

            public void annotationChanged (org.openide.filesystems.FileStatusEvent ev) {

                assertNull (this.ev);

                this.ev = ev;

            }

        }

        L l = new L ();

        try {

            fs.addFileStatusListener (l);

            a2.returnName = "xyz";

            String r = fs.getStatus().annotateName ("my name", java.util.Collections.singleton (fo));

            assertEquals (r, a2.returnName);

            org.openide.filesystems.FileStatusEvent ev;

            ev = new org.openide.filesystems.FileStatusEvent (fs, false, true);

            a3.fireFileStatusChanged (ev);

            assertEquals ("Our listener was called", ev, l.ev);

            l.ev = null;            

            Lkp.ic.remove (a3);

            a3.fireFileStatusChanged (ev);

            assertNull ("Now our listener was not called", l.ev);

        } finally {

            fs.removeFileStatusListener (l);

        }

    }

    private class AnnotationProviderImpl extends AnnotationProvider {

        public java.lang.String annotateName (java.lang.String name, java.util.Set files) {

            return null;

        }

        public java.awt.Image annotateIcon (java.awt.Image icon, int iconType, java.util.Set files) {

            return null;

        }

        public java.lang.String annotateNameHtml (java.lang.String name, java.util.Set files) {

            return null;

        }

        public javax.swing.Action[] actions (java.util.Set files) {

            return null;

        }

    }

    public static final class Lkp extends org.openide.util.lookup.AbstractLookup {

        static org.openide.util.lookup.InstanceContent ic;

        public Lkp () {

            this (new org.openide.util.lookup.InstanceContent ());

        }

        private Lkp (org.openide.util.lookup.InstanceContent ic) {

            super (ic);

            this.ic = ic;

        }

    } // end of Lkp

    static final class AnnoProv extends AnnotationProvider {

        public String returnHtml;

        public String returnName;

        public java.awt.Image returnIcon;

        public javax.swing.Action[] returnActions;

        public String queriedHtml;

        public String queriedName;

        public java.awt.Image queriedIcon;

        public java.util.Set filesHtml;

        public java.util.Set filesName;

        public java.util.Set filesIcon;

        public java.util.Set filesActions;

        public String annotateNameHtml (String name, java.util.Set files) {

            assertNull (queriedHtml);

            queriedHtml = name;

            filesHtml = files;

            return returnHtml;

        }

        public String annotateName (String name, java.util.Set files) {

            assertNull (queriedName);

            queriedName = name;

            filesName = files;

            return returnName;

        }

        public java.awt.Image annotateIcon (java.awt.Image icon, int iconType, java.util.Set files) {

            assertNull (queriedIcon);

            queriedIcon = icon;

            filesIcon = files;

            return returnIcon;

        }

        public javax.swing.Action[] actions (java.util.Set files) {

            assertNull (filesActions);

            filesActions = files;

            return returnActions;

        }

    }

}