<attr name="asynchronous" boolvalue="true"/>

    <change id="Actions.asynchronous">

        <api name="awt"/>

        <summary>Support for asynchronous actions</summary>

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

        <date day="30" month="7" year="2009"/>

        <author login="jtulach"/>

        <compatibility addition="yes" binary="compatible" semantic="compatible" deprecation="no" deletion="no" modification="no"/>

        <description>

            The layer definition used by factory methods for

            <a href="@TOP@/org/openide/awt/Actions.html#context(java.lang.Class,%20boolean,%20boolean,%20org.openide.util.ContextAwareAction,%20java.lang.String,%20javax.swing.Action,%20java.lang.String,%20java.lang.String,%20boolean)">

            context</a>

            and

            <a href="@TOP@/org/openide/awt/Actions.html#callback(java.lang.String,%20javax.swing.Action,%20boolean,%20java.lang.String,%20java.lang.String,%20boolean)">

            callback</a>

            and

            <a href="@TOP@/org/openide/awt/Actions.html#alwaysEnabled(java.awt.event.ActionListener,%20java.lang.String,%20java.lang.String,%20boolean)">

                alwaysEnabledAction</a>

            were enhanced to understand <code>&lt;attr name="asynchronous" boolvalue="true"/&gt;</code>

            attribute. This extends these new factories with capabilities

            already present in old <code>SystemAction</code>, thus makes

            it easier to migrate from old to new while retaining compatible

            behaviour.

        </description>

        <class package="org.openide.awt" name="Actions"/>

        <issue number="168547"/>

    </change>

     *   <!-- if desired: <attr name="asynchronous" boolvalue="true"/> -->

     *   <!-- if desired: <attr name="asynchronous" boolvalue="true"/> -->

     *   <!-- if desired: <attr name="asynchronous" boolvalue="true"/> -->

import org.netbeans.modules.openide.util.ActionsBridge;

import org.netbeans.modules.openide.util.ActionsBridge.ActionRunnable;

import org.netbeans.modules.openide.util.ActionsBridge;

import org.netbeans.modules.openide.util.ActionsBridge.ActionRunnable;

        /** are we asynchronous? */

        private final boolean async;

            this.async = async;

/*

 * 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.awt;

import java.awt.event.ActionEvent;

import java.util.logging.Level;

import javax.swing.AbstractAction;

import javax.swing.Action;

import org.netbeans.junit.Log;

import org.netbeans.junit.NbTestCase;

import org.openide.filesystems.FileUtil;

import org.openide.util.ContextAwareAction;

import org.openide.util.Lookup;

/** Verifies asynchronous aspects of actions systems are close to the

 * original behaviour of SystemAction one.

 * Taken from org.openide.util.actions.AsynchronousTest

 * @author Jaroslav Tulach

 */

public class AsynchronousTest extends NbTestCase {

    private CharSequence err;

    public AsynchronousTest(String name) {

        super(name);

    }

    @Override

    protected int timeOut() {

        return 5000;

    }

    @Override

    protected boolean runInEQ() {

        return true;

    }

    @Override

    protected void setUp() {

        err = Log.enable("", Level.WARNING);

        AC.finished = false;

    }

    public void testExecutionOfActionsThatDoesNotDefineAsynchronousIsSynchronousNoWarningIsPrinted() throws Exception {

        Action action = (Action)FileUtil.getConfigFile("actions/async/none.instance").getAttribute("instanceCreate");

        synchronized (AsynchronousTest.class) {

            action.actionPerformed(new ActionEvent(this, 0, ""));

            assertTrue("The synchronous action is finished immediatelly", AC.finished);

        }

        if (err.length() > 0) {

            fail("There should be no warning about missing asynchronous: " + err);

        }

    }

    public void testExecutionCanBeAsynchronous() throws Exception {

        Action action = (Action)FileUtil.getConfigFile("actions/async/true.instance").getAttribute("instanceCreate");

        synchronized (AsynchronousTest.class) {

            action.actionPerformed(new ActionEvent(this, 0, ""));

            Thread.sleep(500);

            assertFalse("Shall Not be finished yet", AC.finished);

            AsynchronousTest.class.wait();

            assertTrue("The asynchronous action is finished", AC.finished);

        }

        if (err.length() > 0) {

            fail("No warning about the class: " + err);

        }

    }

    public void testExecutionCanBeAsynchronousForAlways() throws Exception {

        Action action = (Action)FileUtil.getConfigFile("actions/async/true-always.instance").getAttribute("instanceCreate");

        synchronized (AsynchronousTest.class) {

            action.actionPerformed(new ActionEvent(this, 0, ""));

            Thread.sleep(500);

            assertFalse("Shall Not be finished yet", AC.finished);

            AsynchronousTest.class.wait();

            assertTrue("The asynchronous action is finished", AC.finished);

        }

        if (err.length() > 0) {

            fail("No warning about the class: " + err);

        }

    }

    public void testExecutionCanBeSynchronous() throws Exception {

        Action action = (Action)FileUtil.getConfigFile("actions/async/false.instance").getAttribute("instanceCreate");

        synchronized (AsynchronousTest.class) {

            action.actionPerformed(new ActionEvent(this, 0, ""));

            assertTrue("The synchronous action is finished immediatelly", AC.finished);

        }

        if (err.length() > 0) {

            fail("No warning about the class: " + err);

        }

    }

    public void testExecutionCanBeForcedToBeSynchronous() throws Exception {

        Action action = (Action)FileUtil.getConfigFile("actions/async/true.instance").getAttribute("instanceCreate");

        synchronized (AsynchronousTest.class) {

            action.actionPerformed(new ActionEvent(this, 0, "waitFinished"));

            assertTrue("When asked for synchronous the action is finished immediatelly", AC.finished);

        }

        if (err.length() > 0) {

            fail("No warning about the class: " + err);

        }

    }

    public void testExecutionCanBeAsynchronousForContext() throws Exception {

        Action action = (Action)FileUtil.getConfigFile("actions/async/true-context.instance").getAttribute("instanceCreate");

        synchronized (AsynchronousTest.class) {

            action.actionPerformed(new ActionEvent(this, 0, ""));

            Thread.sleep(500);

            assertFalse("Shall Not be finished yet", AC.finished);

            AsynchronousTest.class.wait();

            assertTrue("The asynchronous action is finished", AC.finished);

        }

        if (err.length() > 0) {

            fail("No warning about the class: " + err);

        }

    }

    public static class AC extends AbstractAction {

        static boolean finished;

        public void actionPerformed(ActionEvent ev) {

            synchronized (AsynchronousTest.class) {

                AsynchronousTest.class.notifyAll();

                finished = true;

            }

        }

    }

    public static class CAC extends AC implements ContextAwareAction {

        public Action createContextAwareInstance(Lookup actionContext) {

            return this;

        }

    }

}

        <folder name="async">

            <file name="none.instance">

                <attr name='instanceCreate' methodvalue='org.openide.awt.Actions.alwaysEnabled'/>

                <attr name='delegate' newvalue='org.openide.awt.AsynchronousTest$AC'/>

                <attr name='displayName' bundlevalue='org.openide.awt.TestBundle#Always'/>

            </file>

            <file name="true-always.instance">

                <attr name='instanceCreate' methodvalue='org.openide.awt.Actions.alwaysEnabled'/>

                <attr name='delegate' newvalue='org.openide.awt.AsynchronousTest$AC'/>

                <attr name='displayName' bundlevalue='org.openide.awt.TestBundle#Always'/>

                <attr name="asynchronous" boolvalue="true"/>

            </file>

            <file name="true.instance">

                <attr name='instanceCreate' methodvalue='org.openide.awt.Actions.callback'/>

                <attr name='fallback' newvalue='org.openide.awt.AsynchronousTest$AC'/>

                <attr name='key' stringvalue='delete'/>

                <attr name='displayName' bundlevalue='org.openide.awt.TestBundle#Always'/>

                <attr name="asynchronous" boolvalue="true"/>

            </file>

            <file name="true-context.instance">

               <attr name="instanceCreate" methodvalue="org.openide.awt.Actions.context"/>

               <attr name="type" stringvalue="org.netbeans.api.actions.Openable"/>

               <attr name="selectionType" stringvalue="ANY"/>

               <attr name="delegate" newvalue="org.openide.awt.AsynchronousTest$CAC"/>

               <attr name="key" stringvalue="KeyInActionMap"/>

               <attr name="surviveFocusChange" boolvalue="false"/>

               <attr name="displayName" stringvalue="anything"/>

               <attr name="asynchronous" boolvalue="true"/>

            </file>

            <file name="false.instance">

                <attr name='instanceCreate' methodvalue='org.openide.awt.Actions.callback'/>

                <attr name='fallback' newvalue='org.openide.awt.AsynchronousTest$AC'/>

                <attr name='key' stringvalue='delete'/>

                <attr name='displayName' bundlevalue='org.openide.awt.TestBundle#Always'/>

                <attr name="asynchronous" boolvalue="false"/>

            </file>

        </folder>

        implPerformAction(action, r);

    }

    public static void doPerformAction(Action action, final ActionsBridge.ActionRunnable r) {

        implPerformAction(action, r);

    }

    private static void implPerformAction(Action action, final ActionsBridge.ActionRunnable r) {

            this(ev, (Action)action, async);

        }

        public ActionRunnable(ActionEvent ev, Action action, boolean async) {

        public static ActionRunnable create(ActionEvent ev, Action a, boolean async) {

            return new ActionRunnable(ev, a, async) {

                @Override

                protected void run() {

                    action.actionPerformed(ev);

                }

            };

        }