public static final Predicate<UserLibrary> CONTRIBUTED = new Predicate<UserLibrary>() {

@Override

public boolean test(UserLibrary library) {

return library.getTypes() == null || library.getTypes().isEmpty() || library.getTypes().contains("Contributed");

}

};

private static final int RECENT_SKETCHES_MAX_SIZE = 5;

private static boolean commandLine;

public static volatile Base INSTANCE;

public static SplashScreenHelper splashScreenHelper = new SplashScreenHelper(SplashScreen.getSplashScreen());

public static Map<String, Object> FIND_DIALOG_STATE = new HashMap<String, Object>();

private final ContributionInstaller contributionInstaller;

private final LibraryInstaller libraryInstaller;

private ContributionsSelfCheck contributionsSelfCheck;

// set to true after the first time the menu is built.

// so that the errors while building don't show up again.

boolean builtOnce;

// classpath for all known libraries for p5

// (both those in the p5/libs folder and those with lib subfolders

// found in the sketchbook)

static public String librariesClassPath;

// Location for untitled items

static File untitledFolder;

// p5 icon for the window

// int editorCount;

List<Editor> editors = Collections.synchronizedList(new ArrayList<Editor>());

Editor activeEditor;

// these menus are shared so that the board and serial port selections

// are the same for all windows (since the board and serial port that are

// actually used are determined by the preferences, which are shared)

private List<JMenu> boardsCustomMenus;

private List<JMenuItem> programmerMenus;

private final PdeKeywords pdeKeywords;

private final List<JMenuItem> recentSketchesMenuItems;

static public void main(String args[]) throws Exception {

System.setProperty("awt.useSystemAAFontSettings", "on");

System.setProperty("swing.aatext", "true");

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

splashScreenHelper.splashText(tr("Loading configuration..."));

if (OSUtils.isMacOS()) {

ThinkDifferent.init();

}

try {

guardedMain(args);

} catch (Throwable e) {

e.printStackTrace(System.err);

System.exit(255);

}

}

static public void guardedMain(String args[]) throws Exception {

Runtime.getRuntime().addShutdownHook(new Thread(DeleteFilesOnShutdown.INSTANCE));

BaseNoGui.initLogger();

initLogger();

BaseNoGui.initPlatform();

BaseNoGui.getPlatform().init();

BaseNoGui.initPortableFolder();

BaseNoGui.initParameters(args);

System.setProperty("swing.aatext", PreferencesData.get("editor.antialias", "true"));

BaseNoGui.initVersion();

/*

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

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();

// setup the theme coloring fun

Theme.init();

// Set the look and feel before opening the window

try {

BaseNoGui.getPlatform().setLookAndFeel();

} catch (Exception e) {

// ignore

}

// Create a location for untitled sketches

untitledFolder = BaseNoGui.createTempFolder("untitled");

DeleteFilesOnShutdown.add(untitledFolder);

INSTANCE = new Base(args);

}

static public void initLogger() {

Handler consoleHandler = new ConsoleLogger();

consoleHandler.setLevel(Level.ALL);

consoleHandler.setFormatter(new LogFormatter("%1$tl:%1$tM:%1$tS [%4$7s] %2$s: %5$s%n"));

Logger globalLogger = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);

globalLogger.setLevel(consoleHandler.getLevel());

// Remove default

Handler[] handlers = globalLogger.getHandlers();

for(Handler handler : handlers) {

globalLogger.removeHandler(handler);

}

Logger root = Logger.getLogger("");

handlers = root.getHandlers();

for(Handler handler : handlers) {

root.removeHandler(handler);

}

globalLogger.addHandler(consoleHandler);

Logger.getLogger("cc.arduino.packages.autocomplete").setParent(globalLogger);

Logger.getLogger("br.com.criativasoft.cpluslibparser").setParent(globalLogger);

Logger.getLogger(Base.class.getPackage().getName()).setParent(globalLogger);

}

static protected void setCommandLine() {

commandLine = true;

}

static protected boolean isCommandLine() {

return commandLine;

}

// Returns a File object for the given pathname. If the pathname

// is not absolute, it is interpreted relative to the current

// directory when starting the IDE (which is not the same as the

// current working directory!).

static public File absoluteFile(String path) {

return BaseNoGui.absoluteFile(path);

}

public Base(String[] args) throws Exception {

BaseNoGui.notifier = new GUIUserNotifier(this);

this.recentSketchesMenuItems = new LinkedList<JMenuItem>();

CommandlineParser parser = new CommandlineParser(args);

parser.parseArgumentsPhase1();

BaseNoGui.checkInstallationFolder();

String sketchbookPath = BaseNoGui.getSketchbookPath();

// If no path is set, get the default sketchbook folder for this platform

if (sketchbookPath == null) {

File defaultFolder = getDefaultSketchbookFolderOrPromptForIt();

if (BaseNoGui.getPortableFolder() != null)

PreferencesData.set("sketchbook.path", BaseNoGui.getPortableSketchbookFolder());

else

PreferencesData.set("sketchbook.path", defaultFolder.getAbsolutePath());

if (!defaultFolder.exists()) {

defaultFolder.mkdirs();

}

}

splashScreenHelper.splashText(tr("Initializing packages..."));

BaseNoGui.initPackages();

splashScreenHelper.splashText(tr("Preparing boards..."));

rebuildBoardsMenu();

rebuildProgrammerMenu();

// Setup board-dependent variables.

onBoardOrPortChange();

this.pdeKeywords = new PdeKeywords();

this.pdeKeywords.reload();

contributionInstaller = new ContributionInstaller(BaseNoGui.indexer, BaseNoGui.getPlatform(), new GPGDetachedSignatureVerifier());

libraryInstaller = new LibraryInstaller(BaseNoGui.librariesIndexer, BaseNoGui.getPlatform());

parser.parseArgumentsPhase2();

for (String path : parser.getFilenames()) {

// Correctly resolve relative paths

File file = absoluteFile(path);

// 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 (OSUtils.isWindows()) {

try {

file = file.getCanonicalFile();

} catch (IOException e) {

e.printStackTrace();

}

}

boolean showEditor = parser.isGuiMode();

if (!parser.isForceSavePrefs())

PreferencesData.setDoSave(showEditor);

if (handleOpen(file, nextEditorLocation(), showEditor, false) == null) {

String mess = I18n.format(tr("Failed to open sketch: \"{0}\""), path);

// Open failure is fatal in upload/verify mode

if (parser.isVerifyOrUploadMode())

showError(null, mess, 2);

else

showWarning(null, mess, null);

}

}

// Save the preferences. For GUI mode, this happens in the quit

// handler, but for other modes we should also make sure to save

// them.

PreferencesData.save();

if (parser.isInstallBoard()) {

ContributionsIndexer indexer = new ContributionsIndexer(BaseNoGui.getSettingsFolder(), BaseNoGui.getPlatform(), new GPGDetachedSignatureVerifier());

ProgressListener progressListener = new ConsoleProgressListener();

List<String> downloadedPackageIndexFiles = contributionInstaller.updateIndex(progressListener);

contributionInstaller.deleteUnknownFiles(downloadedPackageIndexFiles);

indexer.parseIndex();

indexer.syncWithFilesystem(BaseNoGui.getHardwareFolder());

String[] boardToInstallParts = parser.getBoardToInstall().split(":");

ContributedPlatform selected = null;

if (boardToInstallParts.length == 3) {

selected = indexer.getIndex().findPlatform(boardToInstallParts[0], boardToInstallParts[1], VersionHelper.valueOf(boardToInstallParts[2]).toString());

} else if (boardToInstallParts.length == 2) {

List<ContributedPlatform> platformsByName = indexer.getIndex().findPlatforms(boardToInstallParts[0], boardToInstallParts[1]);

Collections.sort(platformsByName, new DownloadableContributionVersionComparator());

if (!platformsByName.isEmpty()) {

selected = platformsByName.get(platformsByName.size() - 1);

}

}

if (selected == null) {

System.out.println(tr("Selected board is not available"));

System.exit(1);

}

ContributedPlatform installed = indexer.getInstalled(boardToInstallParts[0], boardToInstallParts[1]);

if (!selected.isReadOnly()) {

contributionInstaller.install(selected, progressListener);

}

if (installed != null && !installed.isReadOnly()) {

contributionInstaller.remove(installed);

}

System.exit(0);

} else if (parser.isInstallLibrary()) {

LibrariesIndexer indexer = new LibrariesIndexer(BaseNoGui.getSettingsFolder(), new ContributionsIndexer(BaseNoGui.getSettingsFolder(), BaseNoGui.getPlatform(), new GPGDetachedSignatureVerifier()));

ProgressListener progressListener = new ConsoleProgressListener();

indexer.parseIndex();

BaseNoGui.onBoardOrPortChange();

indexer.setSketchbookLibrariesFolder(BaseNoGui.getSketchbookLibrariesFolder());

indexer.setLibrariesFolders(BaseNoGui.getLibrariesPath());

libraryInstaller.updateIndex(progressListener);

for (String library : parser.getLibraryToInstall().split(",")) {

String[] libraryToInstallParts = library.split(":");

ContributedLibrary selected = null;

if (libraryToInstallParts.length == 2) {

selected = indexer.getIndex().find(libraryToInstallParts[0], VersionHelper.valueOf(libraryToInstallParts[1]).toString());

} else if (libraryToInstallParts.length == 1) {

List<ContributedLibrary> librariesByName = indexer.getIndex().find(libraryToInstallParts[0]);

Collections.sort(librariesByName, new DownloadableContributionVersionComparator());

if (!librariesByName.isEmpty()) {

selected = librariesByName.get(librariesByName.size() - 1);

}

}

if (selected == null) {

System.out.println(tr("Selected library is not available"));

System.exit(1);

}

ContributedLibrary installed = indexer.getIndex().getInstalled(libraryToInstallParts[0]);

if (selected.isReadOnly()) {

libraryInstaller.remove(installed, progressListener);

} else {

libraryInstaller.install(selected, installed, progressListener);

}

}

System.exit(0);

} else if (parser.isVerifyOrUploadMode()) {

splashScreenHelper.close();

// Set verbosity for command line build

PreferencesData.set("build.verbose", "" + parser.isDoVerboseBuild());

PreferencesData.set("upload.verbose", "" + parser.isDoVerboseUpload());

PreferencesData.set("runtime.preserve.temp.files", Boolean.toString(parser.isPreserveTempFiles()));

// Make sure these verbosity preferences are only for the

// current session

PreferencesData.setDoSave(false);

Editor editor = editors.get(0);

if (parser.isUploadMode()) {

splashScreenHelper.splashText(tr("Verifying and uploading..."));

editor.exportHandler.run();

} else {

splashScreenHelper.splashText(tr("Verifying..."));

editor.runHandler.run();

}

// Error during build or upload

if (editor.status.isErr()) {

System.exit(1);

}

// No errors exit gracefully

System.exit(0);

} else if (parser.isGuiMode()) {

splashScreenHelper.splashText(tr("Starting..."));

installKeyboardInputMap();

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

restoreSketches();

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

if (editors.isEmpty()) {

handleNew();

}

// Check for updates

if (PreferencesData.getBoolean("update.check")) {

new UpdateCheck(this);

}

new Thread(new BuiltInCoreIsNewerCheck(this)).start();

contributionsSelfCheck = new ContributionsSelfCheck(this, new UpdatableBoardsLibsFakeURLsHandler(this), BaseNoGui.indexer, contributionInstaller, BaseNoGui.librariesIndexer, libraryInstaller);

new Timer(false).schedule(contributionsSelfCheck, Constants.BOARDS_LIBS_UPDATABLE_CHECK_START_PERIOD);

} else if (parser.isNoOpMode()) {

// Do nothing (intended for only changing preferences)

System.exit(0);

} else if (parser.isGetPrefMode()) {

BaseNoGui.dumpPrefs(parser);

}

}

private void installKeyboardInputMap() {

UIManager.put("RSyntaxTextAreaUI.inputMap", new SketchTextAreaDefaultInputMap());

}

/**

protected boolean restoreSketches() throws Exception {

// figure out window placement

Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();

boolean windowPositionValid = true;

if (PreferencesData.get("last.screen.height") != null) {

// if screen size has changed, the window coordinates no longer

// make sense, so don't use them unless they're identical

int screenW = PreferencesData.getInteger("last.screen.width");

int screenH = PreferencesData.getInteger("last.screen.height");

if ((screen.width != screenW) || (screen.height != screenH)) {

windowPositionValid = false;

}

/*

} else {

windowPositionValid = false;

}

// Iterate through all sketches that were open last time p5 was running.

// If !windowPositionValid, then ignore the coordinates found for each.

// Save the sketch path and window placement for each open sketch

int count = PreferencesData.getInteger("last.sketch.count");

int opened = 0;

for (int i = count - 1; i >= 0; i--) {

String path = PreferencesData.get("last.sketch" + i + ".path");

if (path == null) {

continue;

}

if (BaseNoGui.getPortableFolder() != null) {

File absolute = new File(BaseNoGui.getPortableFolder(), path);

try {

path = absolute.getCanonicalPath();

} catch (IOException e) {

// path unchanged.

}

}

int[] location;

if (windowPositionValid) {

String locationStr = PreferencesData.get("last.sketch" + i + ".location");

location = PApplet.parseInt(PApplet.split(locationStr, ','));

} else {

location = nextEditorLocation();

}

// If file did not exist, null will be returned for the Editor

if (handleOpen(new File(path), location, nextEditorLocation(), true, false, false) != null) {

opened++;

}

}

return (opened > 0);

}

/**

protected void storeSketches() {

// Save the width and height of the screen

Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();

PreferencesData.setInteger("last.screen.width", screen.width);

PreferencesData.setInteger("last.screen.height", screen.height);

String untitledPath = untitledFolder.getAbsolutePath();

// Save the sketch path and window placement for each open sketch

LinkedList<Editor> reverseEditors = new LinkedList<Editor>(editors);

Collections.reverse(reverseEditors);

int index = 0;

for (Editor editor : reverseEditors) {

String path = editor.getSketch().getMainFilePath();

// In case of a crash, save untitled sketches if they contain changes.

// (Added this for release 0158, may not be a good idea.)

if (path.startsWith(untitledPath) && !editor.getSketch().isModified()) {

continue;

}

if (BaseNoGui.getPortableFolder() != null) {

path = FileUtils.relativePath(BaseNoGui.getPortableFolder().toString(), path);

if (path == null) {

continue;

}

}

PreferencesData.set("last.sketch" + index + ".path", path);

int[] location = editor.getPlacement();

String locationStr = PApplet.join(PApplet.str(location), ",");

PreferencesData.set("last.sketch" + index + ".location", locationStr);

index++;

}

PreferencesData.setInteger("last.sketch.count", index);

}

protected void storeRecentSketches(Sketch sketch) {

if (sketch.isUntitled()) {

return;

}

Set<String> sketches = new LinkedHashSet<String>();

sketches.add(sketch.getMainFilePath());

sketches.addAll(PreferencesData.getCollection("recent.sketches"));

PreferencesData.setCollection("recent.sketches", sketches);

}

protected void removeRecentSketchPath(String path) {

Collection<String> sketches = new LinkedList<String>(PreferencesData.getCollection("recent.sketches"));

sketches.remove(path);

PreferencesData.setCollection("recent.sketches", sketches);

}

// 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.

protected void handleActivated(Editor whichEditor) {

activeEditor = whichEditor;

activeEditor.rebuildRecentSketchesMenu();

if (PreferencesData.getBoolean("editor.external")) {

try {

activeEditor.getSketch().load(true);

} catch (IOException e) {

// noop

}

}

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

EditorConsole.setCurrentEditorConsole(activeEditor.console);

}

protected int[] nextEditorLocation() {

int defaultWidth = PreferencesData.getInteger("editor.window.width.default");

int defaultHeight = PreferencesData.getInteger("editor.window.height.default");

if (activeEditor == null) {

Rectangle screen = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration().getBounds();

// If no current active editor, use default placement

return new int[]{

(screen.width - defaultWidth) / 2,

(screen.height - defaultHeight) / 2,

defaultWidth, defaultHeight, 0

};

} else {

Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();

// With a currently active editor, open the new window

// using the same dimensions, but offset slightly.

synchronized (editors) {

final int OVER = 50;

// In release 0160, don't

//location = activeEditor.getPlacement();

Editor lastOpened = activeEditor;

int[] location = lastOpened.getPlacement();

// Just in case the bounds for that window are bad

location[0] += OVER;

location[1] += OVER;

if (location[0] == OVER ||

location[2] == OVER ||

location[0] + location[2] > screen.width ||

location[1] + location[3] > screen.height) {

// Warp the next window to a randomish location on screen.

return new int[]{

(int) (Math.random() * (screen.width - defaultWidth)),

(int) (Math.random() * (screen.height - defaultHeight)),

defaultWidth, defaultHeight, 0

};

}

return location;

}

}

}

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

boolean breakTime = false;

String[] months = {

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

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

};

protected File createNewUntitled() throws IOException {

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 = BaseNoGui.getSketchbookFolder();

File newbieParentDir = untitledFolder;

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

int index = 0;

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

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

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

Calendar cal = Calendar.getInstance();

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

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

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

do {

if (index == 26*26) {

// In 0166, avoid running past zz by sending people outdoors.

if (!breakTime) {

showWarning(tr("Time for a Break"),

tr("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 {

showWarning(tr("Sunshine"),

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

}

return null;

}

int multiples = index / 26;

if(multiples > 0){

newbieName = ((char) ('a' + (multiples-1))) + "" + ((char) ('a' + (index % 26))) + "";

}else{

newbieName = ((char) ('a' + index)) + "";

}

newbieName = "sketch_" + purty + 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(sketchbookDir, newbieName).exists());

// Make the directory for the new sketch

newbieDir.mkdirs();

// Make an empty pde file

File newbieFile = new File(newbieDir, newbieName + ".ino");

if (!newbieFile.createNewFile()) {

throw new IOException();

}

FileUtils.copyFile(new File(getContentFile("examples"), "01.Basics" + File.separator + "BareMinimum" + File.separator + "BareMinimum.ino"), newbieFile);

return newbieFile;

}

/**

public void handleNew() throws Exception {

try {

File file = createNewUntitled();

if (file != null) {

Editor editor = handleOpen(file, true);

}

} catch (IOException e) {

if (activeEditor != null) {

activeEditor.statusError(e);

}

}

}

/**

public void handleNewReplace() {

if (!activeEditor.checkModified()) {

return; // sketch was modified, and user canceled

}

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

activeEditor.internalCloseRunner();

// Actually replace things

handleNewReplaceImpl();

}

protected void handleNewReplaceImpl() {

try {

File file = createNewUntitled();

if (file != null) {

activeEditor.handleOpenInternal(file);

activeEditor.untitled = true;

}

} catch (IOException e) {

activeEditor.statusError(e);

}

}

public void handleOpenReplace(File file) {

if (!activeEditor.checkModified()) {

return; // sketch was modified, and user canceled

}

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

activeEditor.internalCloseRunner();

boolean loaded = activeEditor.handleOpenInternal(file);

if (!loaded) {

// replace the document without checking if that's ok

handleNewReplaceImpl();

}

}

/**

public void handleOpenPrompt() throws Exception {

// get the frontmost window frame for placing file dialog

FileDialog fd = new FileDialog(activeEditor, tr("Open an Arduino sketch..."), FileDialog.LOAD);

File lastFolder = new File(PreferencesData.get("last.folder", BaseNoGui.getSketchbookFolder().getAbsolutePath()));

if (lastFolder.exists() && lastFolder.isFile()) {

lastFolder = lastFolder.getParentFile();

}

fd.setDirectory(lastFolder.getAbsolutePath());

// Only show .pde files as eligible bachelors

fd.setFilenameFilter(new FilenameFilter() {

public boolean accept(File dir, String name) {

return name.toLowerCase().endsWith(".ino")

|| name.toLowerCase().endsWith(".pde");

}

});

fd.setVisible(true);

String directory = fd.getDirectory();

String filename = fd.getFile();

// User canceled selection

if (filename == null) return;

File inputFile = new File(directory, filename);

PreferencesData.set("last.folder", inputFile.getAbsolutePath());

handleOpen(inputFile);

}

/**

public Editor handleOpen(File file) throws Exception {

return handleOpen(file, false);

}

public Editor handleOpen(File file, boolean untitled) throws Exception {

return handleOpen(file, nextEditorLocation(), true, untitled);

}

protected Editor handleOpen(File file, int[] location, boolean showEditor, boolean untitled) throws Exception {

return handleOpen(file, location, location, showEditor, true, untitled);

}

protected Editor handleOpen(File file, int[] storedLocation, int[] defaultLocation, boolean showEditor, boolean storeOpenedSketches, boolean untitled) throws Exception {

if (!file.exists()) return null;

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

String path = file.getAbsolutePath();

for (Editor editor : editors) {

if (editor.getSketch().getMainFilePath().equals(path)) {

editor.toFront();

return editor;

}

}

Editor editor = new Editor(this, file, storedLocation, defaultLocation, BaseNoGui.getPlatform());

// Make sure that the sketch actually loaded

if (editor.getSketch() == null) {

return null; // Just walk away quietly

}

editor.untitled = untitled;

editors.add(editor);

if (storeOpenedSketches) {

// Store information on who's open and running

// (in case there's a crash or something that can't be recovered)

storeSketches();

storeRecentSketches(editor.getSketch());

rebuildRecentSketchesMenuItems();

PreferencesData.save();

}

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

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

if (showEditor) {

SwingUtilities.invokeLater(new Runnable() {

@Override

public void run() {

editor.setVisible(true);

}

});

}

return editor;

}

protected void rebuildRecentSketchesMenuItems() {

Set<File> recentSketches = new LinkedHashSet<File>() {

@Override

public boolean add(File file) {

if (size() >= RECENT_SKETCHES_MAX_SIZE) {

return false;

}

return super.add(file);

}

};

for (String path : PreferencesData.getCollection("recent.sketches")) {

File file = new File(path);

if (file.exists()) {

recentSketches.add(file);

}

}

recentSketchesMenuItems.clear();

for (final File recentSketch : recentSketches) {

JMenuItem recentSketchMenuItem = new JMenuItem(recentSketch.getParentFile().getName());

recentSketchMenuItem.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent actionEvent) {

try {

handleOpen(recentSketch);

} catch (Exception e) {

e.printStackTrace();

}

}

});

recentSketchesMenuItems.add(recentSketchMenuItem);

}

}

/**

public boolean handleClose(Editor editor) {

// Check if modified

if (!editor.checkModified()) {

return false;

}

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

editor.internalCloseRunner();

if (editors.size() == 1) {

// This will store the sketch count as zero

editors.remove(editor);

try {

Editor.serialMonitor.close();

} catch (Exception e) {

//ignore

}

storeSketches();

rebuildRecentSketchesMenuItems();

// Save out the current prefs state

PreferencesData.save();

// Since this wasn't an actual Quit event, call System.exit()

System.exit(0);

} else {

// More than one editor window open,

// proceed with closing the current window.

editor.setVisible(false);

editor.dispose();

editors.remove(editor);

}

return true;