/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */

/*

Part of the Processing project - http://processing.org

Copyright (c) 2012-15 The Processing Foundation

Copyright (c) 2004-12 Ben Fry and Casey Reas

Copyright (c) 2001-04 Massachusetts Institute of Technology

This program is free software; you can redistribute it and/or

modify it under the terms of the GNU General Public License

version 2, as published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software Foundation,

Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

*/

package processing.app;

import java.awt.EventQueue;

import java.awt.FileDialog;

import java.awt.Frame;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.*;

import java.text.SimpleDateFormat;

import java.util.*;

import java.util.zip.*;

import javax.swing.JDialog;

import javax.swing.JFileChooser;

import javax.swing.JFrame;

import javax.swing.JMenu;

import javax.swing.JMenuItem;

import javax.swing.JOptionPane;

import javax.swing.JPopupMenu;

import javax.swing.tree.DefaultMutableTreeNode;

import processing.app.contrib.*;

import processing.app.ui.Editor;

import processing.app.ui.EditorConsole;

import processing.app.ui.EditorState;

import processing.app.ui.PreferencesFrame;

import processing.app.ui.Recent;

import processing.core.*;

import processing.data.StringDict;

import processing.data.StringList;

/**

* The base class for the main processing application.

* Primary role of this class is for platform identification and

* general interaction with the system (launching URLs, loading

* files and images, etc) that comes from that.

*/

public class Base {

// Added accessors for 0218 because the UpdateCheck class was not properly

// updating the values, due to javac inlining the static final values.

static private final int REVISION = 238;

/** This might be replaced by main() if there's a lib/version.txt file. */

static private String VERSION_NAME = "0238"; //$NON-NLS-1$

/** Set true if this a proper release rather than a numbered revision. */

/** True if heavy debugging error/log messages are enabled */

static public boolean DEBUG = false;

// static public boolean DEBUG = true;

static HashMap<Integer, String> platformNames =

new HashMap<Integer, String>();

static {

platformNames.put(PConstants.WINDOWS, "windows"); //$NON-NLS-1$

platformNames.put(PConstants.MACOSX, "macosx"); //$NON-NLS-1$

platformNames.put(PConstants.LINUX, "linux"); //$NON-NLS-1$

}

static HashMap<String, Integer> platformIndices = new HashMap<String, Integer>();

static {

platformIndices.put("windows", PConstants.WINDOWS); //$NON-NLS-1$

platformIndices.put("macosx", PConstants.MACOSX); //$NON-NLS-1$

platformIndices.put("linux", PConstants.LINUX); //$NON-NLS-1$

}

static Platform platform;

/** How many bits this machine is */

static int nativeBits;

static {

nativeBits = 32; // perhaps start with 32

String bits = System.getProperty("sun.arch.data.model"); //$NON-NLS-1$

if (bits != null) {

if (bits.equals("64")) { //$NON-NLS-1$

nativeBits = 64;

}

} else {

// if some other strange vm, maybe try this instead

if (System.getProperty("java.vm.name").contains("64")) { //$NON-NLS-1$ //$NON-NLS-2$

nativeBits = 64;

}

}

}

static private boolean commandLine;

// A single instance of the preferences window

PreferencesFrame preferencesFrame;

// A single instance of the library manager window

ContributionManagerDialog contributionManagerFrame;

// Location for untitled items

static File untitledFolder;

/** List of currently active editors. */

protected List<Editor> editors =

Collections.synchronizedList(new ArrayList<Editor>());

protected Editor activeEditor;

/** A lone file menu to be used when all sketch windows are closed. */

static public JMenu defaultFileMenu;

/**

* Starts with the last mode used with the environment,

* or the default mode if not used.

*/

private Mode nextMode;

/** The built-in modes. coreModes[0] will be considered the 'default'. */

private Mode[] coreModes;

protected ArrayList<ModeContribution> modeContribs;

protected ArrayList<ExamplesContribution> exampleContribs;

private JMenu sketchbookMenu;

private Recent recent;

// Used by handleOpen(), this saves the chooser to remember the directory.

// Doesn't appear to be necessary with the AWT native file dialog.

// https://github.com/processing/processing/pull/2366

private JFileChooser openChooser;

static protected File sketchbookFolder;

// protected File toolsFolder;

static public void main(final String[] args) {

EventQueue.invokeLater(new Runnable() {

public void run() {

try {

createAndShowGUI(args);

} catch (Throwable t) {

showBadnessTrace("It was not meant to be",

"A serious problem happened during startup. Please report:\n" +

"http://github.com/processing/processing/issues/new", t, true);

}

}

});

}

static private void createAndShowGUI(String[] args) {

try {

File versionFile = getContentFile("lib/version.txt"); //$NON-NLS-1$

if (versionFile.exists()) {

String version = PApplet.loadStrings(versionFile)[0];

if (!version.equals(VERSION_NAME)) {

VERSION_NAME = version;

// RELEASE = true;

}

}

} catch (Exception e) {

e.printStackTrace();

}

initPlatform();

// Use native popups so they don't look so crappy on OS X

JPopupMenu.setDefaultLightWeightPopupEnabled(false);

// Don't put anything above this line that might make GUI,

// because the platform has to be inited properly first.

// Make sure a full JDK is installed

//initRequirements();

// Load the languages

Language.init();

// run static initialization that grabs all the prefs

Preferences.init();

// Get the sketchbook path, and make sure it's set properly

locateSketchbookFolder();

// String filename = args.length > 1 ? args[0] : null;

if (!SingleInstance.alreadyRunning(args)) {

// SingleInstance.startServer(platform);

// Set the look and feel before opening the window

try {

platform.setLookAndFeel();

} catch (Exception e) {

// String mess = e.getMessage();

// if (!mess.contains("ch.randelshofer.quaqua.QuaquaLookAndFeel")) {

loge("Could not set the Look & Feel", e); //$NON-NLS-1$

// }

}

// Create a location for untitled sketches

try {

untitledFolder = Base.createTempFolder("untitled", "sketches", null);

untitledFolder.deleteOnExit();

} catch (IOException e) {

Base.showError("Trouble without a name",

"Could not create a place to store untitled sketches.\n" +

"That's gonna prevent us from continuing.", e);

}

log("about to create base..."); //$NON-NLS-1$

try {

Base base = new Base(args);

// Prevent more than one copy of the PDE from running.

SingleInstance.startServer(base);

} catch (Throwable t) {

// Catch-all to pick up badness during startup.

if (t.getCause() != null) {

// Usually this is the more important piece of information. We'll

// show this one so that it's not truncated in the error window.

t = t.getCause();

}

showBadnessTrace("We're off on the wrong foot",

"An error occurred during startup.", t, true);

}

log("done creating base..."); //$NON-NLS-1$

}

}

public static void setCommandLine() {

commandLine = true;

}

static public boolean isCommandLine() {

return commandLine;

}

static public void initPlatform() {

try {

Class<?> platformClass = Class.forName("processing.app.Platform"); //$NON-NLS-1$

if (Base.isMacOS()) {

platformClass = Class.forName("processing.app.platform.MacPlatform"); //$NON-NLS-1$

} else if (Base.isWindows()) {

platformClass = Class.forName("processing.app.platform.WindowsPlatform"); //$NON-NLS-1$

} else if (Base.isLinux()) {

platformClass = Class.forName("processing.app.platform.LinuxPlatform"); //$NON-NLS-1$

}

platform = (Platform) platformClass.newInstance();

} catch (Exception e) {

Base.showError("Problem Setting the Platform",

"An unknown error occurred while trying to load\n" +

"platform-specific code for your machine.", e);

}

}

/*

public static void initRequirements() {

try {

Class.forName("com.sun.jdi.VirtualMachine"); //$NON-NLS-1$

} catch (ClassNotFoundException cnfe) {

//String cp = System.getProperty("java.class.path").replace(File.pathSeparatorChar, '\n');

// String cp = System.getProperty("sun.boot.class.path").replace(File.pathSeparatorChar, '\n');

Base.openURL("http://wiki.processing.org/w/Supported_Platforms");

// Base.showError("Please install JDK 1.6 or later",

// "Processing requires a full JDK (not just a JRE)\n" +

// "to run. Please install JDK 1.6 or later.\n" +

// "More information can be found on the Wiki." +

// "\n\nJAVA_HOME is currently\n" +

// System.getProperty("java.home") + "\n" +

// "And the CLASSPATH contains\n" + cp, cnfe);

Base.showError("Missing required files",

"Processing requires a JRE with tools.jar (or a\n" +

"full JDK) installed in (or linked to) a folder\n" +

"named “java” next to the Processing application.\n" +

"More information can be found on the Wiki.", cnfe);

}

}

*/

// TODO should this be public to suggest override for Arduino and others?

private String getDefaultModeIdentifier() {

//return "processing.mode.java.pdex.ExperimentalMode";

return "processing.mode.java.JavaMode";

}

// TODO same as above... make public?

private void buildCoreModes() {

Mode javaMode =

ModeContribution.load(this, getContentFile("modes/java"), //$NON-NLS-1$

getDefaultModeIdentifier()).getMode(); //$NON-NLS-1$

// PDE X calls getModeList() while it's loading, so coreModes must be set

coreModes = new Mode[] { javaMode };

/*

Mode pdexMode =

ModeContribution.load(this, getContentFile("modes/ExperimentalMode"), //$NON-NLS-1$

"processing.mode.experimental.ExperimentalMode").getMode(); //$NON-NLS-1$

// Safe to remove the old Java mode here?

//coreModes = new Mode[] { pdexMode };

coreModes = new Mode[] { pdexMode, javaMode };

*/

}

/**

* Instantiates and adds new contributed modes to the contribModes list.

* Checks for duplicates so the same mode isn't instantiates twice. Does not

* remove modes because modes can't be removed once they are instantiated.

*/

void rebuildContribModes() {

if (modeContribs == null) {

modeContribs = new ArrayList<ModeContribution>();

}

ModeContribution.loadMissing(this);

// ArrayList<ModeContribution> newContribs =

// ModeContribution.loadAll(getSketchbookModesFolder());

// for (ModeContribution contrib : newContribs) {

// if (!contribModes.contains(contrib)) {

// if (contrib.instantiateModeClass(this)) {

// contribModes.add(contrib);

// }

// }

// }

}

/**

* Instantiates and adds new contributed modes to the contribModes list.

* Checks for duplicates so the same mode isn't instantiates twice. Does not

* remove modes because modes can't be removed once they are instantiated.

*/

void rebuildContribExamples() {

if (exampleContribs == null) {

exampleContribs = new ArrayList<ExamplesContribution>();

}

ExamplesContribution.loadMissing(this);

}

public Base(String[] args) throws Exception {

ContributionManager.cleanup(this);

buildCoreModes();

rebuildContribModes();

rebuildContribExamples();

// Needs to happen after the sketchbook folder has been located.

// Also relies on the modes to be loaded so it knows what can be

// marked as an example.

recent = new Recent(this);

String lastModeIdentifier = Preferences.get("mode.last"); //$NON-NLS-1$

if (lastModeIdentifier == null) {

nextMode = getDefaultMode();

log("Nothing set for last.sketch.mode, using default."); //$NON-NLS-1$

} else {

for (Mode m : getModeList()) {

if (m.getIdentifier().equals(lastModeIdentifier)) {

logf("Setting next mode to %s.", lastModeIdentifier); //$NON-NLS-1$

nextMode = m;

}

}

if (nextMode == null) {

nextMode = getDefaultMode();

logf("Could not find mode %s, using default.", lastModeIdentifier); //$NON-NLS-1$

}

}

contributionManagerFrame = new ContributionManagerDialog();

// Make sure ThinkDifferent has library examples too

nextMode.rebuildLibraryList();

// Put this after loading the examples, so that building the default file

// menu works on Mac OS X (since it needs examplesFolder to be set).

platform.init(this);

// toolsFolder = getContentFile("tools");

// // Check if there were previously opened sketches to be restored

// boolean opened = restoreSketches();

boolean opened = false;

// Check if any files were passed in on the command line

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

String path = args[i];

// Fix a problem with systems that use a non-ASCII languages. Paths are

// being passed in with 8.3 syntax, which makes the sketch loader code

// unhappy, since the sketch folder naming doesn't match up correctly.

// http://dev.processing.org/bugs/show_bug.cgi?id=1089

if (isWindows()) {

try {

File file = new File(args[i]);

path = file.getCanonicalPath();

} catch (IOException e) {

e.printStackTrace();

}

}

if (handleOpen(path) != null) {

opened = true;

}

}

// Create a new empty window (will be replaced with any files to be opened)

if (!opened) {

// System.out.println("opening a new window");

handleNew();

// } else {

// System.out.println("something else was opened");

}

// check for updates

new UpdateCheck(this);

}

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

/** Returns the front most, active editor window. */

public Editor getActiveEditor() {

return activeEditor;

}

/** Get the list of currently active editor windows. */

public List<Editor> getEditors() {

return editors;

}

/**

* The call has already checked to make sure this sketch is not modified,

* now change the mode.

*/

public void changeMode(Mode mode) {

if (activeEditor.getMode() != mode) {

Sketch sketch = activeEditor.getSketch();

nextMode = mode;

if (sketch.isUntitled()) {

// If no changes have been made, just close and start fresh.

// (Otherwise the editor would lose its 'untitled' status.)

handleClose(activeEditor, true);

handleNew();

} else {

// If the current editor contains file extensions that the new mode can handle, then

// write a sketch.properties file with the new mode specified, and reopen.

boolean newModeCanHandleCurrentSource = true;

for (final SketchCode code: sketch.getCode()) {

if (!mode.validExtension(code.getExtension())) {

newModeCanHandleCurrentSource = false;

break;

}

}

if (newModeCanHandleCurrentSource) {

final File props = new File(sketch.getCodeFolder(), "sketch.properties");

saveModeSettings(props, nextMode);

handleClose(activeEditor, true);

handleOpen(sketch.getMainFilePath());

}

}

}

}

public List<ModeContribution> getModeContribs() {

return modeContribs;

}

public List<Mode> getModeList() {

ArrayList<Mode> allModes = new ArrayList<Mode>();

allModes.addAll(Arrays.asList(coreModes));

if (modeContribs != null) {

for (ModeContribution contrib : modeContribs) {

allModes.add(contrib.getMode());

}

}

return allModes;

}

public List<ExamplesContribution> getExampleContribs() {

return exampleContribs;

}

private List<Contribution> getInstalledContribs() {

List<Contribution> contributions = new ArrayList<Contribution>();

List<ModeContribution> modeContribs = getModeContribs();

contributions.addAll(modeContribs);

for (ModeContribution modeContrib : modeContribs) {

Mode mode = modeContrib.getMode();

contributions.addAll(new ArrayList<Library>(mode.contribLibraries));

}

// TODO this duplicates code in Editor, but it's not editor-specific

// List<ToolContribution> toolContribs =

// ToolContribution.loadAll(Base.getSketchbookToolsFolder());

// contributions.addAll(toolContribs);

contributions.addAll(ToolContribution.loadAll(getSketchbookToolsFolder()));

contributions.addAll(getExampleContribs());

return contributions;

}

public byte[] getInstalledContribsInfo() {

List<Contribution> contribs = getInstalledContribs();

StringList entries = new StringList();

for (Contribution c : contribs) {

String entry = c.getTypeName() + "=" +

PApplet.urlEncode(String.format("name=%s\nurl=%s\nrevision=%d\nversion=%s",

c.getName(), c.getUrl(),

c.getVersion(), c.getPrettyVersion()));

entries.append(entry);

}

String joined =

"id=" + Preferences.get("update.id") + "&" + entries.join("&");

// StringBuilder sb = new StringBuilder();

// try {

// // Truly ridiculous attempt to shove everything into a GET request.

// // More likely to be seen as part of a grand plot.

// ByteArrayOutputStream baos = new ByteArrayOutputStream();

// GZIPOutputStream output = new GZIPOutputStream(baos);

// PApplet.saveStream(output, new ByteArrayInputStream(joined.getBytes()));

// output.close();

// byte[] b = baos.toByteArray();

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

// sb.append(PApplet.hex(b[i], 2));

// }

// } catch (IOException e) {

// e.printStackTrace();

// }

// return sb.toString();

return joined.getBytes();

}

// Because of variations in native windowing systems, no guarantees about

// changes to the focused and active Windows can be made. Developers must

// never assume that this Window is the focused or active Window until this

// Window receives a WINDOW_GAINED_FOCUS or WINDOW_ACTIVATED event.

public void handleActivated(Editor whichEditor) {

activeEditor = whichEditor;

// set the current window to be the console that's getting output

EditorConsole.setEditor(activeEditor);

// make this the next mode to be loaded

nextMode = whichEditor.getMode();

Preferences.set("mode.last", nextMode.getIdentifier()); //$NON-NLS-1$

}

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

boolean breakTime = false;

String[] months = {

"jan", "feb", "mar", "apr", "may", "jun",

"jul", "aug", "sep", "oct", "nov", "dec"

};

/**

* Create a new untitled document in a new sketch window.

*/

public void handleNew() {

try {

File newbieDir = null;

String newbieName = null;

// In 0126, untitled sketches will begin in the temp folder,

// and then moved to a new location because Save will default to Save As.

// File sketchbookDir = getSketchbookFolder();

File newbieParentDir = untitledFolder;

String prefix = Preferences.get("editor.untitled.prefix");

// Use a generic name like sketch_031008a, the date plus a char

int index = 0;

String format = Preferences.get("editor.untitled.suffix");

String suffix = null;

if (format == null) {

Calendar cal = Calendar.getInstance();

int day = cal.get(Calendar.DAY_OF_MONTH); // 1..31

int month = cal.get(Calendar.MONTH); // 0..11

suffix = months[month] + PApplet.nf(day, 2);

} else {

//SimpleDateFormat formatter = new SimpleDateFormat("yyMMdd");

//SimpleDateFormat formatter = new SimpleDateFormat("MMMdd");

//String purty = formatter.format(new Date()).toLowerCase();

SimpleDateFormat formatter = new SimpleDateFormat(format);

suffix = formatter.format(new Date());

}

do {

if (index == 26) {

// In 0159, avoid running past z by sending people outdoors.

if (!breakTime) {

Base.showWarning("Time for a Break",

"You've reached the limit for auto naming of new sketches\n" +

"for the day. How about going for a walk instead?", null);

breakTime = true;

} else {

Base.showWarning("Sunshine",

"No really, time for some fresh air for you.", null);

}

return;

}

newbieName = prefix + suffix + ((char) ('a' + index));

// Also sanitize the name since it might do strange things on

// non-English systems that don't use this sort of date format.

// http://code.google.com/p/processing/issues/detail?id=283

newbieName = Sketch.sanitizeName(newbieName);

newbieDir = new File(newbieParentDir, newbieName);

index++;

// Make sure it's not in the temp folder *and* it's not in the sketchbook

} while (newbieDir.exists() || new File(sketchbookFolder, newbieName).exists());

// Make the directory for the new sketch

newbieDir.mkdirs();

// Make an empty pde file

File newbieFile =

new File(newbieDir, newbieName + "." + nextMode.getDefaultExtension()); //$NON-NLS-1$

if (!newbieFile.createNewFile()) {

throw new IOException(newbieFile + " already exists.");

}

// Create sketch properties file if it's not the default mode.

if (!nextMode.equals(getDefaultMode())) {

saveModeSettings(new File(newbieDir, "sketch.properties"), nextMode);

}

String path = newbieFile.getAbsolutePath();

/*Editor editor =*/ handleOpen(path, true);

} catch (IOException e) {

Base.showWarning("That's new to me",

"A strange and unexplainable error occurred\n" +

"while trying to create a new sketch.", e);

}

}

// Create or modify a sketch.proprties file to specify the given Mode.

private void saveModeSettings(final File sketchProps, final Mode mode) {

try {

final Settings settings = new Settings(sketchProps);

settings.set("mode", mode.getTitle());

settings.set("mode.id", mode.getIdentifier());

settings.save();

} catch (IOException e) {

System.err.println("While creating " + sketchProps + ": " + e.getMessage());

}

}

public Mode getDefaultMode() {

return coreModes[0];

}

/** Used by ThinkDifferent so that it can have a Sketchbook menu. */

public Mode getNextMode() {

return nextMode;

}

/**

* Prompt for a sketch to open, and open it in a new window.

*/

public void handleOpenPrompt() {

final ArrayList<String> extensions = new ArrayList<String>();

for (Mode mode : getModeList()) {

extensions.add(mode.getDefaultExtension());

}

final String prompt = Language.text("open");

// don't use native dialogs on Linux (or anyone else w/ override)

if (Preferences.getBoolean("chooser.files.native")) { //$NON-NLS-1$

// use the front-most window frame for placing file dialog

FileDialog openDialog =

new FileDialog(activeEditor, prompt, FileDialog.LOAD);

// Only show .pde files as eligible bachelors

openDialog.setFilenameFilter(new FilenameFilter() {

public boolean accept(File dir, String name) {

// confirmed to be working properly [fry 110128]

for (String ext : extensions) {

if (name.toLowerCase().endsWith("." + ext)) { //$NON-NLS-1$

return true;

}

}

return false;

}

});

openDialog.setVisible(true);

String directory = openDialog.getDirectory();

String filename = openDialog.getFile();

if (filename != null) {

File inputFile = new File(directory, filename);

handleOpen(inputFile.getAbsolutePath());

}

} else {

if (openChooser == null) {

openChooser = new JFileChooser();

}

openChooser.setDialogTitle(prompt);

openChooser.setFileFilter(new javax.swing.filechooser.FileFilter() {

public boolean accept(File file) {

// JFileChooser requires you to explicitly say yes to directories

// as well (unlike the AWT chooser). Useful, but... different.

// http://code.google.com/p/processing/issues/detail?id=1151

if (file.isDirectory()) {

return true;

}

for (String ext : extensions) {

if (file.getName().toLowerCase().endsWith("." + ext)) { //$NON-NLS-1$

return true;

}

}

return false;

}

public String getDescription() {

return "Processing Sketch";

}

});

if (openChooser.showOpenDialog(activeEditor) == JFileChooser.APPROVE_OPTION) {

handleOpen(openChooser.getSelectedFile().getAbsolutePath());

}

}

}

/**

* Open a sketch from the path specified. Do not use for untitled sketches.

*/

public Editor handleOpen(String path) {

return handleOpen(path, false);

}

/**

* Open a sketch in a new window.

* @param path Path to the pde file for the sketch in question

* @return the Editor object, so that properties (like 'untitled')

* can be set by the caller

*/

public Editor handleOpen(String path, boolean untitled) {

return handleOpen(path, untitled, new EditorState(editors));

}

// protected Editor handleOpen(String path, int[] location) {

// protected Editor handleOpen(String path, Rectangle bounds, int divider) {

protected Editor handleOpen(String path, boolean untitled, EditorState state) {

try {

// System.err.println("entering handleOpen " + path);

final File file = new File(path);

if (!file.exists()) {

return null;

}

// Cycle through open windows to make sure that it's not already open.

for (Editor editor : editors) {

// User may have double-clicked any PDE in the sketch folder,

// so we have to check each open tab (not just the main one).

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

for (SketchCode tab : editor.getSketch().getCode()) {

if (tab.getFile().equals(file)) {

editor.toFront();

// move back to the top of the recent list

handleRecent(editor);

return editor;

}

}

}

if (!Sketch.isSanitaryName(file.getName())) {

Base.showWarning("You're tricky, but not tricky enough",

file.getName() + " is not a valid name for a sketch.\n" +

"Better to stick to ASCII, no spaces, and make sure\n" +

"it doesn't start with a number.", null);

return null;

}

if (!nextMode.canEdit(file)) {

final Mode mode = selectMode(file);

if (mode == null) {

return null;

}

nextMode = mode;

}

// Editor.State state = new Editor.State(editors);

Editor editor = null;

try {

editor = nextMode.createEditor(this, path, state);

} catch (NoSuchMethodError nsme) {

Base.showWarning("Mode out of date",

nextMode.getTitle() + " is not compatible with this version of Processing.\n" +

"Try updating the Mode or contact its author for a new version.", nsme);

} catch (Throwable t) {

showBadnessTrace("Mode Problems",

"A nasty error occurred while trying to use " + nextMode.getTitle() + ".\n" +

"It may not be compatible with this version of Processing.\n" +

"Try updating the Mode or contact its author for a new version.", t, false);

}

if (editor == null) {

// if the bad mode is the default mode, don't go into an infinite loop

// trying to recreate a window with the default mode.

Mode defaultMode = getDefaultMode();

if (nextMode == defaultMode) {

Base.showError("Editor Problems",

"An error occurred while trying to change modes.\n" +

"We'll have to quit for now because it's an\n" +

"unfortunate bit of indigestion with the default Mode.",

null);

} else {

editor = defaultMode.createEditor(this, path, state);

}

}

// Make sure that the sketch actually loaded

Sketch sketch = editor.getSketch();

if (sketch == null) {

return null; // Just walk away quietly

}

sketch.setUntitled(untitled);

editors.add(editor);

handleRecent(editor);

// now that we're ready, show the window

// (don't do earlier, cuz we might move it based on a window being closed)

editor.setVisible(true);

return editor;

// } catch (NoSuchMethodError nsme) {

// Base.showWarning(title, message);

} catch (Throwable t) {

showBadnessTrace("Terrible News",

"A serious error occurred while " +

"trying to create a new editor window.", t,

nextMode == getDefaultMode()); // quit if default

nextMode = getDefaultMode();

return null;

}

}

private static class ModeInfo {

public final String title;

public final String id;

public ModeInfo(String id, String title) {

this.id = id;

this.title = title;

}

}

private static ModeInfo modeInfoFor(final File sketch) {

final File sketchFolder = sketch.getParentFile();

final File sketchProps = new File(sketchFolder, "sketch.properties");

if (!sketchProps.exists()) {

return null;

}

try {

final Settings settings = new Settings(sketchProps);

final String title = settings.get("mode");

final String id = settings.get("mode.id");

if (title == null || id == null) {

return null;

}

return new ModeInfo(id, title);

} catch (IOException e) {

System.err.println("While trying to read " + sketchProps + ": "

+ e.getMessage());

}

return null;

}

private Mode promptForMode(final File sketch, final ModeInfo preferredMode) {

final String extension =

sketch.getName().substring(sketch.getName().lastIndexOf('.') + 1);

final List<Mode> possibleModes = new ArrayList<Mode>();

for (final Mode mode : getModeList()) {

if (mode.canEdit(sketch)) {

possibleModes.add(mode);

}

}

if (possibleModes.size() == 1 &&

possibleModes.get(0).getIdentifier().equals(getDefaultModeIdentifier())) {

// If default mode can open it, then do so without prompting.

return possibleModes.get(0);

}

if (possibleModes.size() == 0) {

if (preferredMode == null) {

Base.showWarning("Modeless Dialog",

"I don't know how to open a sketch with the \""

+ extension

+ "\"\nfile extension. You'll have to install a different"

+ "\nProcessing mode for that.");

} else {

Base.showWarning("Modeless Dialog", "You'll have to install "

+ preferredMode.title + " Mode " + "\nin order to open that sketch.");

}

return null;

}

final Mode[] modes = possibleModes.toArray(new Mode[possibleModes.size()]);

final String message = preferredMode == null ?

(nextMode.getTitle() + " Mode can't open ." + extension + " files, " +

"but you have one or more modes\ninstalled that can. " +

"Would you like to try one?") :

("That's a " + preferredMode.title + " Mode sketch, " +

"but you don't have " + preferredMode.title + " installed.\n" +

"Would you like to try a different mode for opening a " +

"." + extension + " sketch?");

return (Mode) JOptionPane.showInputDialog(null, message, "Choose Wisely",

JOptionPane.QUESTION_MESSAGE,

null, modes, modes[0]);

}

private Mode selectMode(final File sketch) {

final ModeInfo modeInfo = modeInfoFor(sketch);

final Mode specifiedMode = modeInfo == null ? null : findMode(modeInfo.id);

if (specifiedMode != null) {

return specifiedMode;

}

return promptForMode(sketch, modeInfo);

}

protected Mode findMode(String id) {

for (Mode mode : getModeList()) {

if (mode.getIdentifier().equals(id)) {

return mode;

}

}

return null;

}

/**

* Close a sketch as specified by its editor window.

* @param editor Editor object of the sketch to be closed.

* @param modeSwitch Whether this close is being done in the context of a

* mode switch.

* @return true if succeeded in closing, false if canceled.

*/

public boolean handleClose(Editor editor, boolean modeSwitch) {

// Check if modified

// boolean immediate = editors.size() == 1;

if (!editor.checkModified()) {

return false;

}

// Close the running window, avoid window boogers with multiple sketches

editor.internalCloseRunner();