I've watched Geert Bevin, from RIFE, a number of times, doing presentations where he talks about 'Save Game' functionality. That's how he presents the concept of 'continuations'. "When playing a computer game," he says, "don't you commonly want to save the game at a point where things are becoming exciting, and then return to it later?"

Aranea has brought this concept to Swing some time ago, on top of the JavaFlow library. However, you need to perform some instrumentation on your classes prior to being able to make use of these continuations. This can be during the build process or at runtime via a special classloader. I don't want to do this from the command line, but as part of some Ant process. I haven't been able to find anywhere a good description, or at least a simple description, of how either of these instrumentations should be done via Ant, exactly, but I spent some time figuring it out, and here is the result, via a handy Ant script, that turned out to be a lot simpler than I thought, which is run after compilation of the classes:

<target name="javaflow" depends="compile, jar" description="javaflow">
    <java classname="${main.class}" dir="${work.dir}" fork="true">
        <jvmarg value="-javaagent:lib/aranea-blocking.jar=mypackage, anotherpackage" />
        <classpath>
            <fileset dir="${build.classes.dir}"/>
        </classpath>
    </java>
</target>

As indicated above, you need a comma separated list of packages.

Once you have run the above script, you'll be able to run code such as the following, which blocks the application and forces it to wait for actions applicable to specified Swing components. For example:

@Resumable
public void init() {
    initComponents();
    ResumableRunnable myRunnable = new ResumableRunnable() {
        public void run() {
            for (int i = 1; i <= 10; i++) {
                SwingBlockingUtil.waitForOneAction(someButton);
                System.out.println("You have clicked me " + i);
            }
            System.exit(0);
        }
    };
    BlockingUtil.execute(myRunnable);
}

Finally, the annotation indicates that the method can be resumed later.

Take careful note of the information supplied at the end of the documentation referred to above: "Nothing comes for free and this is doubly so for bytecode modification. JavaFlow will definitely add a performance penalty to your application. However you should consider that it will almost exclusively add CPU consumption and will not stress IO or memory. This means that in most projects the impact will not be considerable or possibly even noticeable. This goes specially to desktop Swing applications, which are highly unlikely to be CPU-bound. Of course one should stress-test the application to make sure what the impact is in your environment."