<file name="templateDataObjectInLayer.java" url="../wizard/loader/templateDataObjectInLayer.javx"/>

import java.net.MalformedURLException;

import java.net.URL;

import org.openide.util.Exceptions;

        boolean loaderlessObject;

        boolean lookupReadyObject;

        try {

            SpecificationVersion current = model.getModuleInfo().getDependencyVersion("org.openide.loaders");

            loaderlessObject = current.compareTo(new SpecificationVersion("7.1")) >= 0; // NOI18N

            lookupReadyObject = current.compareTo(new SpecificationVersion("6.0")) >= 0; // NOI18N

        } catch (IOException ex) {

            Logger.getLogger(NewLoaderIterator.class.getName()).log(Level.INFO, null, ex);

            loaderlessObject = false;

            lookupReadyObject = false;

        }

        String relativeIconPath;

            relativeIconPath = null;

<#assign licenseFirst = "/*">

<#assign licensePrefix = " * ">

<#assign licenseLast = " */">

<#include "../Licenses/license-${project.license}.txt">

package ${PACKAGENAME};

import java.io.IOException;

import org.openide.filesystems.FileObject;

import org.openide.loaders.DataNode;

import org.openide.loaders.DataObjectExistsException;

import org.openide.loaders.MultiDataObject;

import org.openide.loaders.MultiFileLoader;

import org.openide.nodes.CookieSet;

import org.openide.nodes.Node;

import org.openide.nodes.Children;

import org.openide.util.Lookup;

${EDITOR_SUPPORT_IMPORT}

public class ${PREFIX}DataObject extends MultiDataObject {

    public ${PREFIX}DataObject(FileObject pf, MultiFileLoader loader) throws DataObjectExistsException, IOException {

        super(pf, loader);

${EDITOR_SUPPORT_SNIPPET}

    }

    @Override

    protected Node createNodeDelegate() {

        return new DataNode(this, Children.LEAF, getLookup());

    }

    @Override

    public Lookup getLookup() {

        return getCookieSet().getLookup();

    }

}

     <change id="factory">

        <api name="loaders"/>

        <summary>DataObjects without DataLoaders</summary>

        <version major="7" minor="1"/>

        <date day="11" month="6" year="2008"/>

        <author login="jtulach"/>

        <compatibility addition="yes" binary="compatible" />

        <description>

        <p>

            There is new method to register new DataObject types without

            the need to write own DataLoader. Use

            <a href="@TOP@/org/openide/loaders/DataLoaderPool.html#factory(java.lang.Class,%20java.lang.String,%20java.awt.Image)">

                DataLoaderPool.factory</a> method.

        </p>

        </description>

        <class package="org.openide.loaders" name="DataLoaderPool" />

        <issue number="91665"/>

    </change>

import java.awt.Image;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

     private java.awt.Image getImageFromFactory(int type) {

         MimeFactory<?> fact = getLookup().lookup(MimeFactory.class);

         return fact != null ? fact.getImage(type) : null;

     }

    @Override

    @Override

        }

        MimeFactory<?> mime = getLookup().lookup(MimeFactory.class);

        if (mime != null) {

            return mime.getActions();

        } finally {

            exitAllowConstructor (prev);

        }

        return ret;

    }

    /** Calls into one loader. Setups security condition to allow DataObject ocnstructor

     * to succeed.

     */

    public static DataObject handleFindDataObject (DataObject.Factory factory, FileObject fo, Set<? super FileObject> rec) 

    throws java.io.IOException {

        DataObject ret;

        Collection<Item> prev = enterAllowContructor();

        try {

            // make sure this thread is allowed to recognize

            getPOOL ().enterRecognition(fo);

            ret = factory.findDataObject (fo, rec);

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * Contributor(s):

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 */

package org.openide.loaders;

import java.awt.Image;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.Collections;

import java.util.Set;

import javax.swing.Action;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileStateInvalidException;

import org.openide.filesystems.Repository;

import org.openide.util.Exceptions;

import org.openide.util.Lookup;

import org.openide.util.Utilities;

/** Default DataObject.Factory implementation.

 * 

 * @author Jaroslav Tulach

 * @param <T> type of DataObject to create

 */

class MimeFactory<T extends DataObject> implements DataObject.Factory {

    final Class<? extends T> clazz;

    final Constructor<? extends T> factory;

    final String mimeType;

    Image img;

    final FileObject fo;

    public MimeFactory(Class<? extends T> clazz, String mimeType, Image img, FileObject fo) {

        super();

        this.clazz = clazz;

        this.mimeType = mimeType;

        this.img = img;

        try {

            this.factory = clazz.getConstructor(FileObject.class, MultiFileLoader.class);

            this.factory.setAccessible(true);

        } catch (NoSuchMethodException ex) {

            throw (IllegalStateException) new IllegalStateException(ex.getMessage()).initCause(ex);

        }

        this.fo = fo;

    }

    public static MimeFactory<DataObject> layer(FileObject fo) throws ClassNotFoundException {

        String className = (String) fo.getAttribute("dataObjectClass"); // NOI18N

        if (className == null) {

            throw new IllegalStateException("No attribute dataObjectClass for " + fo);

        }

        String mimeType = (String)fo.getAttribute("mimeType"); // NOI18N

        ClassLoader l = Lookup.getDefault().lookup(ClassLoader.class);

        if (l == null) {

            l = Thread.currentThread().getContextClassLoader();

        }

        if (l == null) {

            l = MimeFactory.class.getClassLoader();

        }

        Class<? extends DataObject> clazz = l.loadClass(className).asSubclass(DataObject.class);

        return new MimeFactory<DataObject>(clazz, mimeType, null, fo);

    }

    public DataObject findDataObject(FileObject fo, Set<? super FileObject> recognized) throws IOException {

        DataObject obj = null;

        Exception e = null;

        try {

            obj = factory.newInstance(fo, DataLoaderPool.getDefaultFileLoader());

        } catch (InstantiationException ex) {

            e = ex;

        } catch (IllegalAccessException ex) {

            e = ex;

        } catch (IllegalArgumentException ex) {

            e = ex;

        } catch (InvocationTargetException ex) {

            if (ex.getTargetException() instanceof IOException) {

                throw (IOException)ex.getTargetException();

            }

            e = ex;

        }

        if (obj == null) {

            throw (IOException) new IOException(e.getMessage()).initCause(e);

        }

        if (obj instanceof MultiDataObject) {

            MultiDataObject mdo = (MultiDataObject) obj;

            mdo.getCookieSet().assign(DataObject.Factory.class, this);

        }

        return obj;

    }

    final Image getImage(int type) {

        if (img == null && fo != null) {

            img = Utilities.loadImage("org/openide/loaders/empty.gif", true); // NOI18N

            try {

                img = fo.getFileSystem().getStatus().annotateIcon(img, type, Collections.singleton(fo));

            } catch (FileStateInvalidException ex) {

                Exceptions.printStackTrace(ex);

            }

        }

        return img;

    }

    final Action[] getActions() {

        FileObject actions = Repository.getDefault().getDefaultFileSystem().findResource(

            "Loaders/" + mimeType + "/Actions"

        );

        if (actions != null) {

            DataFolder folder = DataFolder.findFolder(actions);

            try {

                return (Action[]) new DataLdrActions(folder, null).instanceCreate();

            } catch (IOException ex) {

                Exceptions.printStackTrace(ex);

            } catch (ClassNotFoundException ex) {

                Exceptions.printStackTrace(ex);

            }

        }

        return DataLoaderPool.getDefaultFileLoader().getSwingActions();

    }

}

import java.awt.Image;

import java.awt.Toolkit;

import java.awt.image.ImageObserver;

import java.lang.ref.Reference;

import java.lang.ref.WeakReference;

import java.net.URL;

import javax.swing.Action;

import org.openide.actions.EditAction;

import org.openide.nodes.Node;

import org.openide.util.Utilities;

    private static <F extends DataObject.Factory> void addRemove(String mime, F factory, boolean add) throws IOException {

        String res = "Loaders/" + mime + "/Factories/" + factory.getClass().getSimpleName().replace('.', '-') + ".instance";

        FileObject root = Repository.getDefault().getDefaultFileSystem().getRoot();

        if (add) {

            FileObject fo = FileUtil.createData(root, res);

            fo.setAttribute("instanceCreate", factory);

            assertSame("No serialization, just memory fs is used", factory, fo.getAttribute("instanceCreate"));

        } else {

            FileObject fo = root.getFileObject(res);

            if (fo != null) {

                fo.delete();

            }

        }

    }

        }

    }

    public void testFactoryInstanceRegistrationWorksAsWell() throws Exception {

        URL u = DataLoaderInLayerTest.class.getResource("/org/openide/loaders/saveAll.gif");

        Image img = Toolkit.getDefaultToolkit().createImage(u);

        DataObject.Factory f = DataLoaderPool.factory(SimpleDataObject.class, "text/simplefactory", img);

        addRemove("text/plain", f, true);

        try {

            FileSystem lfs = createFS("folderF/file.simple");

            FileObject fo = lfs.findResource("folderF");

            DataFolder df = DataFolder.findFolder(fo);

            DataObject[] arr = df.getChildren();

            assertEquals("One object", 1, arr.length);

            DataObject dob = arr[0];

            assertEquals(SimpleDataObject.class, dob.getClass());

            FileObject root = Repository.getDefault().getDefaultFileSystem().getRoot();

            FileObject edit = FileUtil.createData(root, "/Loaders/text/simplefactory/Actions/org-openide-actions-EditAction.instance");

            Node node = dob.getNodeDelegate();

            Action[] actions = node.getActions(true);

            assertEquals("One action is present: " + Arrays.asList(actions), 1, actions.length);

            assertEquals("It is the edit one", EditAction.class, actions[0].getClass());

            assertSame("Icon is propagated for open", img, node.getOpenedIcon(0));

            assertSame("Icon is propagated", img, node.getIcon(0));

            Reference<DataFolder> ref = new WeakReference<DataFolder>(df);

            df = null;

            assertGC("Folder can go away", ref);

            df = DataFolder.findFolder(fo);

            arr = df.getChildren();

            assertEquals("One object", 1, arr.length);

            assertEquals("Object is the same", dob, arr[0]);

        } finally {

            addRemove("text/plain", f, false);

        }

    }

    public void testFactoryInstanceRegistrationWorksAsWellNowFromLayer() throws Exception {

        URL u = DataLoaderInLayerTest.class.getResource("/org/openide/loaders/saveAll.gif");

        FileObject root = Repository.getDefault().getDefaultFileSystem().getRoot();

        FileObject instance = FileUtil.createData(root, "TestLoaders/text/L.instance");

        instance.setAttribute("dataObjectClass", SimpleDataObject.class.getName());

        instance.setAttribute("mimeType", "text/simplefactory");

        instance.setAttribute("SystemFileSystem.icon", u);

        Image img = Utilities.loadImage("org/openide/loaders/saveAll.gif");

        DataObject.Factory f = DataLoaderPool.factory(instance);

        addRemove("text/plain", f, true);

        try {

            FileSystem lfs = createFS("folderQ/file.simple");

            FileObject fo = lfs.findResource("folderQ");

            DataFolder df = DataFolder.findFolder(fo);

            DataObject[] arr = df.getChildren();

            assertEquals("One object", 1, arr.length);

            DataObject dob = arr[0];

            assertEquals(SimpleDataObject.class, dob.getClass());

            FileObject edit = FileUtil.createData(root, "/Loaders/text/simplefactory/Actions/org-openide-actions-EditAction.instance");

            Node node = dob.getNodeDelegate();

            Action[] actions = node.getActions(true);

            assertEquals("One action is present: " + Arrays.asList(actions), 1, actions.length);

            assertEquals("It is the edit one", EditAction.class, actions[0].getClass());

            assertImage("Icon is propagated for open", img, node.getOpenedIcon(0));

            assertImage("Icon is propagated", img, node.getIcon(0));

            Reference<DataFolder> ref = new WeakReference<DataFolder>(df);

            df = null;

            assertGC("Folder can go away", ref);

            df = DataFolder.findFolder(fo);

            arr = df.getChildren();

            assertEquals("One object", 1, arr.length);

            assertEquals("Object is the same", dob, arr[0]);

        } finally {

            addRemove("text/plain", f, false);