Since there haven't been any replies to this post yet, I thought I'd ask the question in another way.

What is the 'right' way to call a Processing sketch from a Java application? E.g.

Code:

public class MyApplication {
  static public void main(String[] args0) {
    // do some stuff

    ???? 
    // Call to Processing sketch
    // This may or may not actually show the applet
    // At the moment I'm just using it to write a PDF file.

    // do some more stuff
  }
}
 

With the whole lot called, after compilation, as
Code:

java MyApplication 
 

Thanks.

Thanks for the response but in the first post, you'll see that I have extended PApplet. The problem is how to call a sketch that extends PApplet from another application and have it return predictably.

Sorry, I'm not used to YABB syntax.  Those links are:
http://processing.org/discourse/yabb_beta/YaBB.cgi?board=Collaboration;action=display;num=1210808972;start=2#2
http://www.friendsofed.com/extras/159059617X/Integrating-Processing-Within-Java.pdf

tacitdynamite: Thanks for the link. I've seen that before but the problem is in closing the app. It calls System.exit(0), which I'm trying to avoid in my application (see this thread)

fry: yes the code works within processing. My problem though is more generally about how to get called sketches to return without killing the JVM (again see the thread above).

At the moment I've got this ugly solution, using a controller class to start the sketch in its own Thread group. The controller can then be called to kill the entire thread group of the sketch. However it only seems to work with the stupid sleep command; I've tried adding a "finished" flag to the called sketch but no luck (note the blocked out chunk of code).

Code:

public class ProcessingController {

int timeout = 20000;
Process p = null;
String classname = null;


/**
 * Class constructor specifying class name of sketch
 * 
 * @param classname
 */

public ProcessingController(String classname) {
  this.classname = classname;
}


/**
 * Draws the sketch
 */
public void draw() {
 try {
   p = ProcessingController.startAnotherClassInItsOwnThread(classname, new String[]{}); 
 } catch (Exception e) {
  e.printStackTrace();
 }

 // Necessary ugliness starts here
 try {
   Thread.sleep(timeout);
 } catch (InterruptedException e) {
   e.printStackTrace();
 }

 // Preferred solution which doesn't work
 /* while (!PDFGraph.isDone()) {}
  * if (p!=null) {
  * p.terminate();
  *  }
  */

  p.terminate();

}


private static Process startAnotherClassInItsOwnThread(String classname, String[] args) {
  Process process = new Process(classname, args);
  ThreadGroup threadgroup = new ThreadGroup("main");
  Thread thread = new Thread(threadgroup, process);
  thread.start();
  return process;
}
}

 

This calls the Process class which actually starts the sketch. The terminate method uses the deprecated stop() to stop the ThreadGroup held by the Process.

This all seems way too complicated. All I want to do is:
- start a sketch from within a program
- check is that sketch is finished
- once it's finished, stop all the processing stuff (not the JVM) and return nicely to the calling program

Thanks!

Sorry I must be missing something. How do I get the sketch to stop without calling exit? (in an automated sketch, which doesn't display to the user but writes to file, and uses the draw loop)