/**

private Activity activity;

/** The PGraphics renderer associated with this PApplet */

public PGraphics g;

static final public boolean DEBUG = false;

/** The frame containing this applet (if any) */

/**

public int displayWidth, displayHeight;

/**

/**

public String sketchPath; //folder;

/** When debugging headaches */

/** Default width and height for applet when not specified */

/**

/**

static public class RendererChangeException extends RuntimeException { }

protected boolean surfaceReady;

/**

protected boolean surfaceChanged;

/**

/**

public int[] pixels;

/** width of this applet's associated PGraphics */

public int width;

/** height of this applet's associated PGraphics */

public int height;

// can't call this because causes an ex, but could set elsewhere

//final float screenDensity = getResources().getDisplayMetrics().density;

/** absolute x position of input on screen */

public int mouseX;

/** absolute x position of input on screen */

public int mouseY;

/**

public int pmouseX, pmouseY;

/**

protected int dmouseX, dmouseY;

/**

protected int emouseX, emouseY;

public boolean mousePressed;

/** Post events to the main thread that created the Activity */

Handler handler;

/**

public char key;

/**

public int keyCode;

/**

public boolean keyPressed;

/**

/**

public boolean focused = false;

protected boolean windowFocused = false;

protected boolean viewFocused = false;

/**

/**

long millisOffset = System.currentTimeMillis();

/**

public float frameRate = 10;

/** Last time in nanoseconds that frameRate was checked */

protected long frameRateLastNanos = 0;

/** As of release 0116, frameRate(60) is called as a default */

protected float frameRateTarget = 60;

protected long frameRatePeriod = 1000000000L / 60L;

protected boolean looping;

/** flag set to true when a redraw is asked for by the user */

protected boolean redraw;

/**

public int frameCount;

/**

public boolean finished;

/**

protected boolean paused;

protected SurfaceView surfaceView;

/**

/**

protected boolean exitCalled;

Thread thread;

// messages to send if attached as an external vm

/**

static public final String ARGS_EDITOR_LOCATION = "--editor-location";

/**

static public final String ARGS_EXTERNAL = "--external";

static public final String ARGS_LOCATION = "--location";

static public final String ARGS_DISPLAY = "--display";

static public final String ARGS_BGCOLOR = "--bgcolor";

static public final String ARGS_PRESENT = "--present";

static public final String ARGS_EXCLUSIVE = "--exclusive";

static public final String ARGS_STOP_COLOR = "--stop-color";

static public final String ARGS_HIDE_STOP = "--hide-stop";

/**

static public final String ARGS_SKETCH_FOLDER = "--sketch-path";

/**

//static public final String EXTERNAL_QUIT = "__QUIT__";

static public final String EXTERNAL_STOP = "__STOP__";

/**

static public final String EXTERNAL_MOVE = "__MOVE__";

/** true if this sketch is being run by the PDE */

boolean external = false;

static final String ERROR_MIN_MAX =

"Cannot use min() or max() on an empty array.";

boolean insideSettings;

String renderer = JAVA2D;

int smooth = 1; // default smoothing (whatever that means for the renderer)

boolean fullScreen = false;

// Background default needs to be different from the default value in

// PGraphics.backgroundColor, otherwise size(100, 100) bg spills over.

// https://github.com/processing/processing/issues/2297

int windowColor = 0xffDDDDDD;

//////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////

/**

public PApplet() {}

/** Called with the activity is first created. */

@SuppressWarnings("unchecked")

@Override

public View onCreateView(LayoutInflater inflater, ViewGroup container,

Bundle savedInstanceState) {

if (DEBUG) println("onCreateView() happening here: " + Thread.currentThread().getName());

activity = getActivity();

View rootView;

DisplayMetrics dm = new DisplayMetrics();

activity.getWindowManager().getDefaultDisplay().getMetrics(dm);

displayWidth = dm.widthPixels;

displayHeight = dm.heightPixels;

//Setting the default height and width to be fullscreen

width = displayWidth;

height = displayHeight;

if (DEBUG) println("display metrics: " + dm);

//println("screen size is " + screenWidth + "x" + screenHeight);

handleSettings();

int sw = sketchWidth();

int sh = sketchHeight();

// Get renderer name and class

String rendererName = sketchRenderer();

Class<?> rendererClass = null;

try {

rendererClass = Class.forName(rendererName);

} catch (ClassNotFoundException exception) {

String message = String.format(

"Error: Could not resolve renderer class name: %s", rendererName);

throw new RuntimeException(message, exception);

}

if (rendererName.equals(JAVA2D)) {

// JAVA2D renderer

surfaceView = new SketchSurfaceView(activity, sw, sh,

(Class<? extends PGraphicsAndroid2D>) rendererClass);

} else if (PGraphicsOpenGL.class.isAssignableFrom(rendererClass)) {

// P2D, P3D, and any other PGraphicsOpenGL-based renderer

surfaceView = new SketchSurfaceViewGL(activity, sw, sh,

(Class<? extends PGraphicsOpenGL>) rendererClass);

} else {

// Anything else

String message = String.format(

"Error: Unsupported renderer class: %s", rendererName);

throw new RuntimeException(message);

}

//set smooth level

if (smooth == 0) {

g.noSmooth();

} else {

g.smooth(smooth);

}

//lp.addRule(, arg1)

//layout.addView(surfaceView, sketchWidth(), sketchHeight());

if (sw == displayWidth && sh == displayHeight) {

// If using the full screen, don't embed inside other layouts

rootView = surfaceView;

} else {

// If not using full screen, setup awkward view-inside-a-view so that

// the sketch can be centered on screen. (If anyone has a more efficient

// way to do this, please file an issue on Google Code, otherwise you

// can keep your "talentless hack" comments to yourself. Ahem.)

RelativeLayout overallLayout = new RelativeLayout(activity);

RelativeLayout.LayoutParams lp =

new RelativeLayout.LayoutParams(LayoutParams.WRAP_CONTENT,

LayoutParams.WRAP_CONTENT);

lp.addRule(RelativeLayout.CENTER_IN_PARENT);

LinearLayout layout = new LinearLayout(activity);

layout.addView(surfaceView, sketchWidth(), sketchHeight());

overallLayout.addView(layout, lp);

rootView = overallLayout;

}

/*

// TODO probably don't want to set these here, can't we wait for surfaceChanged()?

// removing this in 0187

// android:layout_width

// code below here formerly from init()

//millisOffset = System.currentTimeMillis(); // moved to the variable declaration

finished = false; // just for clarity

// this will be cleared by draw() if it is not overridden

looping = true;

redraw = true; // draw this guy once

sketchPath = activity.getFilesDir().getAbsolutePath();

handler = new Handler();

start();

return rootView;

}

@Override

public void onConfigurationChanged(Configuration newConfig) {

if (DEBUG) System.out.println("configuration changed: " + newConfig);

super.onConfigurationChanged(newConfig);

}

@Override

public void onResume() {

super.onResume();

// TODO need to bring back app state here!

if (DEBUG) System.out.println("PApplet.onResume() called");

paused = false;

handleMethods("resume");

//start(); // kick the thread back on

resume();

}

@Override

public void onPause() {

super.onPause();

// TODO need to save all application state here!

paused = true;

handleMethods("pause");

pause(); // handler for others to write

}

/**

boolean insideSettings(String method, Object... args) {

if (insideSettings) {

return true;

}

final String url = "https://processing.org/reference/" + method + "_.html";

if (!external) { // post a warning for users of Eclipse and other IDEs

StringList argList = new StringList(args);

System.err.println("When not using the PDE, " + method + "() can only be used inside settings().");

System.err.println("Remove the " + method + "() method from setup(), and add the following:");

System.err.println("public void settings() {");

System.err.println(" " + method + "(" + argList.join(", ") + ");");

System.err.println("}");

}

throw new IllegalStateException(method + "() cannot be used here, see " + url);

}

void handleSettings() {

insideSettings = true;

//Do stuff

settings();

insideSettings = false;

}

public void settings() {

//It'll be empty. Will be overridden by user's sketch class.

}

/**

public void pause() {

}

/**

public void resume() {

}

@Override

public void onDestroy() {

dispose();

if (PApplet.DEBUG) {

System.out.println("PApplet.onDestroy() called");

}

super.onDestroy();

//finish();

}

//////////////////////////////////////////////////////////////

// ANDROID SURFACE VIEW

// TODO this is only used by A2D, when finishing up a draw. but if the

// surfaceview has changed, then it might belong to an a3d surfaceview. hrm.

public SurfaceHolder getSurfaceHolder() {

return surfaceView.getHolder();

}

/** Not official API, not guaranteed to work in the future. */

public SurfaceView getSurfaceView() {

return surfaceView;

}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

public class SketchSurfaceView extends SurfaceView implements

SurfaceHolder.Callback {

PGraphicsAndroid2D g2;

SurfaceHolder surfaceHolder;

public SketchSurfaceView(Context context, int wide, int high,

Class<? extends PGraphicsAndroid2D> clazz) {

super(context);

// Install a SurfaceHolder.Callback so we get notified when the

// underlying surface is created and destroyed

surfaceHolder = getHolder();

surfaceHolder.addCallback(this);

if (clazz.equals(PGraphicsAndroid2D.class)) {

g2 = new PGraphicsAndroid2D();

} else {

try {

Constructor<? extends PGraphicsAndroid2D> constructor =

clazz.getConstructor();

g2 = constructor.newInstance();

} catch (Exception exception) {

throw new RuntimeException(

"Error: Failed to initialize custom Android2D renderer",

exception);

}

}

// Set semi-arbitrary size; will be set properly when surfaceChanged() called

g2.setSize(wide, high);

g2.setParent(PApplet.this);

g2.setPrimary(true);

// Set the value for 'g' once everything is ready (otherwise rendering

// may attempt before setSize(), setParent() etc)

g = g2; // assign the g object for the PApplet

setFocusable(true);

setFocusableInTouchMode(true);

requestFocus();

}

// part of SurfaceHolder.Callback

public void surfaceCreated(SurfaceHolder holder) {

}

// part of SurfaceHolder.Callback

public void surfaceDestroyed(SurfaceHolder holder) {

//g2.dispose();

}

// part of SurfaceHolder.Callback

public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {

if (DEBUG) {

System.out.println("SketchSurfaceView2D.surfaceChanged() " + w + " " + h);

}

surfaceChanged = true;

}

@Override

public void onWindowFocusChanged(boolean hasFocus) {

super.onWindowFocusChanged(hasFocus);

surfaceWindowFocusChanged(hasFocus);

}

@Override

public boolean onTouchEvent(MotionEvent event) {

return surfaceTouchEvent(event);

}

@Override

public boolean onKeyDown(int code, android.view.KeyEvent event) {

surfaceKeyDown(code, event);

return super.onKeyDown(code, event);

}

@Override

public boolean onKeyUp(int code, android.view.KeyEvent event) {

surfaceKeyUp(code, event);

return super.onKeyUp(code, event);

}

// don't think i want to call stop() from here, since it might be swapping renderers

}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

public class SketchSurfaceViewGL extends GLSurfaceView {

PGraphicsOpenGL g3;

SurfaceHolder surfaceHolder;

@SuppressWarnings("deprecation")

public SketchSurfaceViewGL(Context context, int wide, int high,

Class<? extends PGraphicsOpenGL> clazz) {

super(context);

// Check if the system supports OpenGL ES 2.0.

final ActivityManager activityManager = (ActivityManager) activity.getSystemService(Context.ACTIVITY_SERVICE);

final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();

final boolean supportsGLES2 = configurationInfo.reqGlEsVersion >= 0x20000;

if (!supportsGLES2) {

throw new RuntimeException("OpenGL ES 2.0 is not supported by this device.");

}

surfaceHolder = getHolder();

// are these two needed?

surfaceHolder.addCallback(this);

surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_GPU);

// The PGraphics object needs to be created here so the renderer is not

// null. This is required because PApplet.onResume events (which call

// this.onResume() and thus require a valid renderer) are triggered

// before surfaceChanged() is ever called.

if (clazz.equals(PGraphics2D.class)) { // P2D

g3 = new PGraphics2D();

} else if (clazz.equals(PGraphics3D.class)) { // P3D

g3 = new PGraphics3D();

} else { // something that extends P2D, P3D, or PGraphicsOpenGL

try {

Constructor<? extends PGraphicsOpenGL> constructor =

clazz.getConstructor();

g3 = constructor.newInstance();

} catch (Exception exception) {

throw new RuntimeException(

"Error: Failed to initialize custom OpenGL renderer",

exception);

}

}

//set it up

g3.setParent(PApplet.this);

g3.setPrimary(true);

// Set semi-arbitrary size; will be set properly when surfaceChanged() called

g3.setSize(wide, high);

// Tells the default EGLContextFactory and EGLConfigChooser to create an GLES2 context.

setEGLContextClientVersion(2);

int quality = sketchQuality();

if (1 < quality) {

setEGLConfigChooser(((PGLES)g3.pgl).getConfigChooser(quality));

}

// The renderer can be set only once.

setRenderer(((PGLES)g3.pgl).getRenderer());

setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);

// assign this g to the PApplet

g = g3;

setFocusable(true);

setFocusableInTouchMode(true);

requestFocus();

}

public PGraphics getGraphics() {

return g3;

}

// part of SurfaceHolder.Callback

@Override

public void surfaceCreated(SurfaceHolder holder) {

super.surfaceCreated(holder);

if (DEBUG) {

System.out.println("surfaceCreated()");

}

}

// part of SurfaceHolder.Callback

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

super.surfaceDestroyed(holder);

if (DEBUG) {

System.out.println("surfaceDestroyed()");

}

/*

}

@Override

public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {

super.surfaceChanged(holder, format, w, h);

if (DEBUG) {

System.out.println("SketchSurfaceView3D.surfaceChanged() " + w + " " + h);

}

surfaceChanged = true;