set flag AllPublic.

lib 1013739

import processing.core.*;

static <A extends PApplet2> Pair<A, Frame> pMain2(final Class<A> c) {

  ret swing(func -> Pair<A, Frame> {

    A a = nuInstance(c);

    Frame f = pMain2_runSketch(null, a);

    clearThreadLocal(PApplet2_instancesMade);

    ret pair(a, f);

  });

}

static PApplet2 pMain2() {

  ret pMain2(mc());

}

static Frame pMain2_runSketch(final String[] args,

                               final PApplet constructedSketch) {

  // Supposed to help with flicker, but no effect on OS X.

  // TODO IIRC this helped on Windows, but need to double check.

  System.setProperty("sun.awt.noerasebackground", "true");

  // Remove 60fps limit on the JavaFX "pulse" timer

  System.setProperty("javafx.animation.fullspeed", "true");

  // Doesn't seem to do anything helpful here (that can't be done via Runner)

  //System.setProperty("com.apple.mrj.application.apple.menu.about.name", "potato");

  Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

    public void uncaughtException(Thread t, Throwable e) {

      e.printStackTrace();

      uncaughtThrowable = e;

    }

  });

  // This doesn't work, need to mess with Info.plist instead

  /*

  // In an exported application, add the Contents/Java folder to the

  // java.library.path, so that native libraries work properly.

  // Without this, the library path is only set to Contents/MacOS

  // where the launcher binary lives.

  if (platform == MACOSX) {

    URL coreJarURL =

      PApplet.class.getProtectionDomain().getCodeSource().getLocation();

    // The jarPath from above will/may be URL encoded (%20 for spaces)

    String coreJarPath = urlDecode(coreJarURL.getPath());

    if (coreJarPath.endsWith("/Contents/Java/core.jar")) {

      // remove the /core.jar part from the end

      String javaPath = coreJarPath.substring(0, coreJarPath.length() - 9);

      String libraryPath = System.getProperty("java.library.path");

      libraryPath += File.pathSeparator + javaPath;

      System.setProperty("java.library.path", libraryPath);

    }

  }

  */

  // Catch any HeadlessException to provide more useful feedback

  try {

    // Call validate() while resize events are in progress

    Toolkit.getDefaultToolkit().setDynamicLayout(true);

  } catch (HeadlessException e) {

    System.err.println("Cannot run sketch without a display. Read this for possible solutions:");

    System.err.println("https://github.com/processing/processing/wiki/Running-without-a-Display");

    System.exit(1);

  }

  // So that the system proxy setting are used by default

  System.setProperty("java.net.useSystemProxies", "true");

  if (args.length < 1) {

    System.err.println("Usage: PApplet [options] <class name> [sketch args]");

    System.err.println("See the Javadoc for PApplet for an explanation.");

    System.exit(1);

  }

  boolean external = false;

  int[] location = null;

  int[] editorLocation = null;

  String name = null;

  int windowColor = 0;

  int stopColor = 0xff808080;

  boolean hideStop = false;

  int displayNum = -1;  // use default

//    boolean fullScreen = false;

  boolean present = false;

//    boolean spanDisplays = false;

  int density = -1;

  String param = null, value = null;

  String folder = calcSketchPath();

  int argIndex = 0;

  while (argIndex < args.length) {

    int equals = args[argIndex].indexOf('=');

    if (equals != -1) {

      param = args[argIndex].substring(0, equals);

      value = args[argIndex].substring(equals + 1);

      if (param.equals(ARGS_EDITOR_LOCATION)) {

        external = true;

        editorLocation = parseInt(split(value, ','));

      } else if (param.equals(ARGS_DISPLAY)) {

        displayNum = parseInt(value, -1);

        if (displayNum == -1) {

          System.err.println("Could not parse " + value + " for " + ARGS_DISPLAY);

        }

      } else if (param.equals(ARGS_WINDOW_COLOR)) {

        if (value.charAt(0) == '#' && value.length() == 7) {

          value = value.substring(1);

          windowColor = 0xff000000 | Integer.parseInt(value, 16);

        } else {

          System.err.println(ARGS_WINDOW_COLOR + " should be a # followed by six digits");

        }

      } else if (param.equals(ARGS_STOP_COLOR)) {

        if (value.charAt(0) == '#' && value.length() == 7) {

          value = value.substring(1);

          stopColor = 0xff000000 | Integer.parseInt(value, 16);

        } else {

          System.err.println(ARGS_STOP_COLOR + " should be a # followed by six digits");

        }

      } else if (param.equals(ARGS_SKETCH_FOLDER)) {

        folder = value;

      } else if (param.equals(ARGS_LOCATION)) {

        location = parseInt(split(value, ','));

      } else if (param.equals(ARGS_DENSITY)) {

        density = parseInt(value, -1);

        if (density == -1) {

          System.err.println("Could not parse " + value + " for " + ARGS_DENSITY);

        } else if (density != 1 && density != 2) {

          density = -1;

          System.err.println(ARGS_DENSITY + " should be 1 or 2");

        }

      }

    } else {

      if (args[argIndex].equals(ARGS_PRESENT)) {

        present = true;

//        } else if (args[argIndex].equals(ARGS_SPAN_DISPLAYS)) {

//          spanDisplays = true;

      } else if (args[argIndex].equals(ARGS_HIDE_STOP)) {

        hideStop = true;

      } else if (args[argIndex].equals(ARGS_EXTERNAL)) {

        external = true;

      } else {

        name = args[argIndex];

        break;  // because of break, argIndex won't increment again

      }

    }

    argIndex++;

  }

//    // Now that sketch path is passed in args after the sketch name

//    // it's not set in the above loop(the above loop breaks after

//    // finding sketch name). So setting sketch path here.

//    // https://github.com/processing/processing/commit/0a14835e6f5f4766b022e73a8fe562318636727c

//    // TODO this is a hack added for PDE X and needs to be removed [fry 141104]

//    for (int i = 0; i < args.length; i++) {

//      if (args[i].startsWith(ARGS_SKETCH_FOLDER)){

//        folder = args[i].substring(args[i].indexOf('=') + 1);

//      }

//    }

  final PApplet sketch;

  if (constructedSketch != null) {

    sketch = constructedSketch;

  } else {

    try {

      Class<?> c =

        Thread.currentThread().getContextClassLoader().loadClass(name);

      sketch = (PApplet) c.newInstance();

    } catch (RuntimeException re) {

      // Don't re-package runtime exceptions

      throw re;

    } catch (Exception e) {

      // Package non-runtime exceptions so we can throw them freely

      throw new RuntimeException(e);

    }

  }

  if (platform == MACOSX) {

    try {

      final String td = "processing.core.ThinkDifferent";

      Class<?> thinkDifferent =

        Thread.currentThread().getContextClassLoader().loadClass(td);

      Method method =

        thinkDifferent.getMethod("init", new Class[] { PApplet.class });

      method.invoke(null, new Object[] { sketch });

    } catch (Exception e) {

      e.printStackTrace();  // That's unfortunate

    }

  }

  // Set the suggested display that's coming from the command line

  // (and most likely, from the PDE's preference setting).

  sketch.display = displayNum;

  // Set the suggested density that is coming from command line

  // (most likely set from the PDE based on a system DPI scaling)

  sketch.suggestedDensity = density;

  sketch.present = present;

  // For 3.0.1, moved this above handleSettings() so that loadImage() can be

  // used inside settings(). Sets a terrible precedent, but the alternative

  // of not being able to size a sketch to an image is driving people loopy.

  // A handful of things that need to be set before init/start.

//    if (folder == null) {

//      folder = calcSketchPath();

//    }

  sketch.sketchPath = folder;

  // Don't set 'args' to a zero-length array if it should be null [3.0a8]

  if (args.length != argIndex + 1) {

    // pass everything after the class name in as args to the sketch itself

    // (fixed for 2.0a5, this was just subsetting by 1, which didn't skip opts)

    sketch.args = PApplet.subset(args, argIndex + 1);

  }

  // Call the settings() method which will give us our size() call

//    try {

  sketch.handleSettings();

//    } catch (Throwable t) {

//      System.err.println("I think I'm gonna hurl");

//    }

////    sketch.spanDisplays = spanDisplays;

//    // If spanning screens, that means we're also full screen.

////    fullScreen |= spanDisplays;

//    if (spanDisplays) {

//      displayIndex = SPAN;

////      fullScreen = true;

//    }

//    // If the applet doesn't call for full screen, but the command line does,

//    // enable it. Conversely, if the command line does not, don't disable it.

//    // Query the applet to see if it wants to be full screen all the time.

//    //fullScreen |= sketch.sketchFullScreen();

//    sketch.fullScreen |= fullScreen;

  sketch.external = external;

  if (windowColor != 0) {

    sketch.windowColor = windowColor;

  }

  final PSurface surface = sketch.initSurface();

//      sketch.initSurface(windowColor, displayIndex, fullScreen, spanDisplays);

  /*

  // Wait until the applet has figured out its width. In a static mode app,

  // everything happens inside setup(), so this will be after setup() has

  // completed, and the empty draw() has set "finished" to true.

  while (sketch.defaultSize && !sketch.finished) {

    //System.out.println("default size");

    try {

      Thread.sleep(5);

    } catch (InterruptedException e) {

      //System.out.println("interrupt");

    }

  }

  */

  if (present) {

    if (hideStop) {

      stopColor = 0;  // they'll get the hint

    }

    surface.placePresent(stopColor);

  } else {

    surface.placeWindow(location, editorLocation);

  }

  // not always running externally when in present mode

  // moved above setVisible() in 3.0 alpha 11

  if (sketch.external) {

    surface.setupExternalMessages();

  }

  sketch.showSurface();

  sketch.startSurface();

  /*

  if (sketch.getGraphics().displayable()) {

    surface.setVisible(true);

  }

  //sketch.init();

  surface.startThread();

  */

  ret frame;

}