import java.awt.EventQueue; import javax.swing.JFrame; import javax.swing.JButton; import javax.swing.JComboBox; import java.awt.event.ActionListener; import java.awt.event.ActionEvent;

public class main {

private JFrame frame;
private JComboBox comboBox ;

/**
 * Launch the application.
 */
public static void main(String[] args) {
    //PApplet.main("ProjectUsingProcessing");
    EventQueue.invokeLater(new Runnable() {
        public void run() {
            try {
                main window = new main();
                window.frame.setVisible(true);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
}

/**
 * Create the application.
 */
public main() {
    initialize();
}

/**
 * Initialize the contents of the frame.
 */
private void initialize() {
    frame = new JFrame();
    frame.setBounds(100, 100, 450, 300);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.getContentPane().setLayout(null);

    JButton btnNewButton = new JButton("New button");
    btnNewButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            String selected = comboBox.getSelectedItem().toString();

            if(selected=="Image1")
            {
                Image1 o1 = new Image1();
                o1.imageDraw();
            }
        }
    });
    btnNewButton.setBounds(29, 30, 89, 23);
    frame.getContentPane().add(btnNewButton);

    comboBox = new JComboBox();
    comboBox.setBounds(29, 104, 142, 23);
    comboBox.addItem("Image1");
    frame.getContentPane().add(comboBox);
}

}

JFrameTest.pde

Frame frame;
void setup(){
  frame = new Frame();
  size(300, 300);
}

void draw(){

}

Frame.pde

import javax.swing.*;

class Frame extends JFrame {
  public Frame(){
    super("Panel");
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setSize(250, 250);
    this.setResizable(false);

    this.setVisible( true );
  }
}

I understand that in this case, Frame is a nested class of JFrameTest in Java. In my app, this isn't the case. I use the PApplet.main method to start Processing sketches but I'm curious if there is a solution from with the PDE!

"As of Processing 3.0, we have removed Applet as the base class for PApplet. This means that we can remove lots of legacy code, however one downside is that it's no longer possible (without extra code) to embed a PApplet into another Java application"

ok. But i would be very happy to understand by an example what kind of "extra code" i could use... thanks in advance

After a thorough search on the Internet and reading the source codes, I could get a solution, which does not work properly.

Here is a baby example of what I have so far followed by the screenshots of my issue (the example uses JFrame for simplicity and conciseness).

public class Visualiser3D extends PApplet {

    private PeasyCam camera;

    @ Override
    public void settings() {
        size(1000, 800, P3D);
    }

    @ Override
    public void setup() {
        camera = new PeasyCam(this, 0, 0, 0, 1500);
    }

    @ Override
    public void draw() {
        camera();        // force default coordsys
        camera.feed();   // manually set peasycam
        background(30);
        sphere(200);    // draw a sphere
    }

    public static void main (String[] args) {
        // prepare JFrame
        JFrame frame = new JFrame("Processing in JFrame");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(new BorderLayout());

        // run Processing
        Visualiser3D mp3d = new Visualiser3D();
        PApplet.runSketch(new String[]{"MyPapplet 3D"}, mp3d);
        PSurfaceJOGL pSurfaceJOGL = (PSurfaceJOGL) mp3d.getSurface();
        pSurfaceJOGL.initOffscreen(mp3d);
        // add canvas to JFrame (used as a Component)
        NewtCanvasAWT canvas = (NewtCanvasAWT) pSurfaceJOGL.getComponent();
        frame.add(canvas, BorderLayout.CENTER);        
        pSurfaceJOGL.startThread();

        // display
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
} 

Here are the screenshots of what I get. The actual processing window keeps running, and if I close it programmatically, the entire application gets closed. I would like to have the Processing canvas embedded inside of my Java Swing application without any other open windows.

I hope that you will be able to help me do it properly. Thank you very much.

My main question is :- Is it appropriate for a library, such as G4P, to use this method to create multiple windows in a PS3 sketch? If not what is?

In the following code I have been experimenting with the args argument to this method. Based on my research the code below should open the secondary window in the top left corner but it uses the default screen centre instead. Any thoughts?
EDIT this problem was solved thanks to GoToLoop's PS3 code below

EDIT this code has been corrected for PS3

// Main sketch (first) tab

void settings(){
  size(600, 200);  
}

void setup() {
  String[] args = {"--location=0,0", "Foo"};
  Foo sa = new Foo(320, 240);
  PApplet.runSketch(args, sa);
}

void draw() {
  background(0);
  ellipse(50, 50, 10, 10);
}     

// Foo.java tab

import processing.core.*;

public class Foo extends PApplet {

  private final int w, h;

  public Foo() {
    w = 200;
    h = 200;
  }

  public Foo(int w, int h) {
    this.w = w;
    this.h = h;
  }

  public void settings() {
    size(w, h);
  }

  public void draw() {
    background(255);
    fill(0);
    ellipse(100, 50, 10, 10);
  }
}

Apologies if I've missed the answer to this one, but I have spent a long time looking.

I'm using Processing3 to display a game for use by school children in a Visitor's Centre. The game is mouse-driven but I can't risk displaying a close button on the frame as someone will use it... Is there any way of producing an undecorated frame in processing 3. The only suggestions I've seen involve the 'frame.' commands which don't appear to work in P3?

Leaving the sketch using the escape key is OK as the keyboard will be locked-away.

If it can be avoided, I'd rather not have this window full-screen, though that is still an outside option.

Thanks,

Batroost

I am working on updating G4P for PS3 and I have managed to create multiple windows with either JAVA2D, P2D or P3D renderers. The problem is that the secondary Window created by Processing, when closed exits the application. In the existing version of G4P the user can specify what to do when the user clicks on the red cross. Either keep the window open, close the window or exit the application and I am trying to do the same thing for PS3.

So the code below is a cut down version to demonstrate the problem. In line 16 the user can specify which of these 3 actions is used. The CLOSE_WINDOW and EXIT_APP work as expected but the KEEP_OPEN option still allows the window to close. :(

In the G3WindowA class the intAWTlisteners() method removes all existing WindowListeners and then adds one of its own (inner class WindowListenerAWT).

This is exactly the same approach I used in the last version of G4P which worked fine in 2.2.1

Any help would be appreciated.

Main sketch tab

// These are used by the secondary window to test mouse event
int x, y;
float a;

public void settings() {
  size(100, 100);
}

public void setup() {
  // Creates a window with a JAVA2D renderer 
  // (do not change renderers in this test)
  G3WindowA g3w = G3WindowA.getWindow("My window", 20, 40, 480, 320, JAVA2D);
  // KEEP_OPEN - ignore attempt to close window (default action) <br>
  // CLOSE_WINDOW - close this window, if it is the main window it causes the app to exit <br>
  // EXIT_APP - exit the app, this will cause all windows to close. <br>
  g3w.setActionOnClose(G3WindowA.KEEP_OPEN);
  g3w.addDrawHandler(this, "g3wDraw");
}

public void draw() {
  background(0);
  ellipse(mouseX, mouseY, 20, 20);
}     

// Draw and mouse event handlers for secondary window
public void g3wDraw(PApplet app, GWinData data) {
  app.background(255);
  app.fill(0);
  app.ellipse(app.mouseX, app.mouseY, 10, 10);
}

G3WindowA.java tab

import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.lang.reflect.Method;

import processing.core.PApplet;

public final class G3WindowA extends PApplet {

  /**
   * Factory method to create and start a new window
   * 
   * @param title text to appear in frame title bar
   * @param px horizontal position of top-left corner
   * @param py vertical position of top-left corner
   * @param w width of drawing surface
   * @param h height of surface
   * @param r renderer e.g. JAVA2D, P3D etc.
   * @return the window created (in case the user wants its.
   */
  public static G3WindowA getWindow(String title, int px, int py, int w, int h, String r) {
    G3WindowA g3w = new G3WindowA(title, w, h, r);
    String loc = "--location=" + px + "," + py;
    String className = g3w.getClass().getName();
    String[] args = { loc, className};
    PApplet.runSketch(args, g3w);
    return g3w;
  }

  /** The object to handle the draw event */
  private Object drawHandlerObject = null;
  /** The method in drawHandlerObject to execute */
  private Method drawHandlerMethod = null;
  /** the name of the method to handle the event */
  private String drawHandlerMethodName;

  //*********************************************************
  // Copied from GConstants
  public static final int EXIT_APP       = 0x00000f01;
  public static final int CLOSE_WINDOW     = 0x00000f02;
  public static final int KEEP_OPEN       = 0x00000f03;
  //**********************************************************

  static final int _INVALID = 0;
  static final int _AWT = 1;      // JAVA2D
  static final int _NEWT = 2;    // P2D or P3D

  private int renderer_type = _INVALID;

  private int actionOnClose = KEEP_OPEN;

  public GWinData data;

  private final int w, h;
  private final String r, title;

  private WindowListener awtAdapter = new WindowListenerAWT();

  private G3WindowA(String title, int w, int h, String renderer) {
    this.title = title;
    this.w = w;
    this.h = h;
    this.r = renderer;
    renderer_type = _INVALID;
    if (renderer.equals(JAVA2D))
      renderer_type = _AWT;
    else if (renderer.equals(P2D) || renderer.equals(P3D))
      renderer_type = _NEWT;
    System.out.println(renderer_type);
    registerMethod("draw", this);
  }

  public void settings() {
    size(w, h, r);
  }

  public void setup() {
    surface.setTitle(title); // does not like this in settings  
    Object obj = surface.getNative();
    System.out.println(obj.getClass().getName());
    switch(renderer_type) {
    case _AWT:
      processing.awt.PSurfaceAWT.SmoothCanvas awtCanvas = (processing.awt.PSurfaceAWT.SmoothCanvas) obj;
      //System.out.println(awtCanvas.getFrame().getClass().getName());
      frame = awtCanvas.getFrame();
      intAWTlisteners();
      break;
    }
  }

  // Remove all WindowListeners and add own own
  private void intAWTlisteners() {
    frame = ((processing.awt.PSurfaceAWT.SmoothCanvas) surface.getNative()).getFrame();
    for (WindowListener l : frame.getWindowListeners())
      frame.removeWindowListener(l);
    frame.addWindowListener(awtAdapter);
  }

  public void draw() {
    pushMatrix();
    if (drawHandlerObject != null) {
      try {
        drawHandlerMethod.invoke(drawHandlerObject, new Object[] { this, data });
      } 
      catch (Exception e) {
        //  ERROR
      }
    }
    popMatrix();
  }

  /**
   * Attempt to add the 'draw' handler method. 
   * The default event handler is a method that returns void and has two
   * parameters PApplet and GWinData
   * 
   * @param obj the object to handle the event
   * @param methodName the method to execute in the object handler class
   */
  public void addDrawHandler(Object obj, String methodName) {
    try {
      drawHandlerMethod = obj.getClass().getMethod(methodName, new Class<?>[] {PApplet.class, GWinData.class } );
      drawHandlerObject = obj;
      drawHandlerMethodName = methodName;
    } 
    catch (Exception e) {
      drawHandlerObject = null;
      //GMessenger.message(NONEXISTANT, new Object[] {this, methodName, new Class<?>[] { PApplet.class, GWinData.class } } );
    }
  }

  /**
   * This sets what happens when the users attempts to close the window. <br>
   * There are 3 possible actions depending on the value passed. <br>
   * KEEP_OPEN - ignore attempt to close window (default action) <br>
   * CLOSE_WINDOW - close this window, if it is the main window it causes the app to exit <br>
   * EXIT_APP - exit the app, this will cause all windows to close. <br>
   * @param action the required close action
   */
  public void setActionOnClose(int action) {
    actionOnClose = action;
  }

  /**
   * Window adapter class that remembers the window it belongs to so
   * it can be used to mark it for closure if required.
   * 
   * @author Peter Lager
   */
  public class WindowListenerAWT implements WindowListener {

    @Override
      public void windowClosing(WindowEvent evt) {
      System.out.println("CLOSING AWT");
      switch(actionOnClose) {
        case EXIT_APP:
          System.out.println("EXIT");
        System.exit(0);
        break;
      case CLOSE_WINDOW:
        System.out.println("CLOSE");
        noLoop();
        unregisterMethod("draw", this);
        dispose();
        break;
      default:
        System.out.println("KEEP OPEN");
      }
    }

    @Override
      public void windowOpened(WindowEvent e) {
    }

    @Override
      public void windowClosed(WindowEvent e) {
      System.out.println("AWT WINDOW CLOSED");
    }

    @Override
      public void windowIconified(WindowEvent e) {
    }

    @Override
      public void windowDeiconified(WindowEvent e) {
    }

    @Override
      public void windowActivated(WindowEvent e) {
    }

    @Override
      public void windowDeactivated(WindowEvent e) {
    }
  }
}

GWinData.java tab

public class GWinData {
}

Why has the setDefaultCloseOperation no effect?

(Also, it should be DISPOSE_ON_CLOSE but I'm using DO_NOTHING_ON_CLOSE for testing).

public class AllSketches extends PApplet {

    public static void main(String[] args) {
        PApplet.main("forMyself.AllSketches", args);
    }

    P5_BackFaceCulling backFaceCulling;

    public void setup() {


        // works
        ((JFrame)getFrame()).setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);

    }

    public void draw() {

    }

    public void keyPressed() {
        if (key == '1') {
            println("test");

            Frame f = backFaceCulling.getFrame();

            if (f instanceof JFrame) {
                // why has this no effect?
                ((JFrame)f).setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
                println("changed setDefaultCloseOperation");
            }

        }
    }

}