public static final int REVISION = 101;

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

static String VERSION_NAME = "0101";

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

static public boolean RELEASE = false;

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

static {

platformNames.put(PConstants.WINDOWS, "windows");

platformNames.put(PConstants.MACOSX, "macosx");

platformNames.put(PConstants.LINUX, "linux");

}

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

static {

platformIndices.put("windows", PConstants.WINDOWS);

platformIndices.put("macosx", PConstants.MACOSX);

platformIndices.put("linux", PConstants.LINUX);

}

static Platform platform;

static private boolean commandLine;

// A single instance of the preferences window

Preferences preferencesFrame;

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

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

boolean builtOnce;

static File buildFolder;

// these are static because they're used by Sketch

static private File examplesFolder;

static private File librariesFolder;

static private File toolsFolder;

static private File hardwareFolder;

static HashSet<File> libraries;

// maps imported packages to their library folder

static HashMap<String, File> importToLibraryTable;

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

static public HashMap<String, Target> targetsTable;

// Location for untitled items

static File untitledFolder;

// p5 icon for the window

java.util.List<Editor> editors =

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

Editor activeEditor;

static public void main(String args[]) {

try {

File versionFile = getContentFile("lib/version.txt");

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

// run static initialization that grabs all the prefs

Preferences.init(null);

// load the I18n module for internationalization

I18n.init(Preferences.get("editor.languages.current"));

// setup the theme coloring fun

Theme.init();

// Set the look and feel before opening the window

try {

platform.setLookAndFeel();

} catch (Exception e) {

String mess = e.getMessage();

if (mess.indexOf("ch.randelshofer.quaqua.QuaquaLookAndFeel") == -1) {

System.err.println(_("Non-fatal error while setting the Look & Feel."));

System.err.println(_("The error message follows, however Arduino should run fine."));

System.err.println(mess);

}

}

// Create a location for untitled sketches

untitledFolder = createTempFolder("untitled");

untitledFolder.deleteOnExit();

new Base(args);

}

static protected void setCommandLine() {

commandLine = true;

}

static protected boolean isCommandLine() {

return commandLine;

}

static protected void initPlatform() {

try {

Class<?> platformClass = Class.forName("processing.app.Platform");

if (Base.isMacOS()) {

platformClass = Class.forName("processing.app.macosx.Platform");

} else if (Base.isWindows()) {

platformClass = Class.forName("processing.app.windows.Platform");

} else if (Base.isLinux()) {

platformClass = Class.forName("processing.app.linux.Platform");

}

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

}

}

static protected void initRequirements() {

try {

Class.forName("com.sun.jdi.VirtualMachine");

} catch (ClassNotFoundException cnfe) {

Base.showPlatforms();

Base.showError(_("Please install JDK 1.5 or later"),

_("Arduino requires a full JDK (not just a JRE)\n" +

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

"More information can be found in the reference."), cnfe);

}

}

public Base(String[] args) {

platform.init(this);

// Get paths for the libraries and examples in the Processing folder

//String workingDirectory = System.getProperty("user.dir");

examplesFolder = getContentFile("examples");

librariesFolder = getContentFile("libraries");

toolsFolder = getContentFile("tools");

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

String sketchbookPath = Preferences.get("sketchbook.path");

// If a value is at least set, first check to see if the folder exists.

// If it doesn't, warn the user that the sketchbook folder is being reset.

if (sketchbookPath != null) {

File skechbookFolder = new File(sketchbookPath);

if (!skechbookFolder.exists()) {

Base.showWarning(_("Sketchbook folder disappeared"),

_("The sketchbook folder no longer exists.\n" +

"Arduino will switch to the default sketchbook\n" +

"location, and create a new sketchbook folder if\n" +

"necessary. Arduino will then stop talking about\n" +

"himself in the third person."), null);

sketchbookPath = null;

}

}

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

if (sketchbookPath == null) {

File defaultFolder = getDefaultSketchbookFolder();

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

if (!defaultFolder.exists()) {

defaultFolder.mkdirs();

}

}

targetsTable = new HashMap<String, Target>();

loadHardware(getHardwareFolder());

loadHardware(getSketchbookHardwareFolder());

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

boolean opened = restoreSketches();

// 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) {

handleNew();

}

// check for updates

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

new UpdateCheck(this);

}

}

/**

protected boolean restoreSketches() {

// figure out window placement

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

boolean windowPositionValid = true;

if (Preferences.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 = Preferences.getInteger("last.screen.width");

int screenH = Preferences.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 = Preferences.getInteger("last.sketch.count");

int opened = 0;

for (int i = 0; i < count; i++) {

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

int[] location;

if (windowPositionValid) {

String locationStr = Preferences.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(path, location) != null) {

opened++;

}

}

return (opened > 0);

}

/**

protected void storeSketches() {

// Save the width and height of the screen

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

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

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

String untitledPath = untitledFolder.getAbsolutePath();

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

int index = 0;

for (Editor editor : editors) {

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;

}

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

int[] location = editor.getPlacement();

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

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

index++;

}

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

}

// If a sketch is untitled on quit, may need to store the new name

// rather than the location from the temp folder.

protected void storeSketchPath(Editor editor, int index) {

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

String untitledPath = untitledFolder.getAbsolutePath();

if (path.startsWith(untitledPath)) {

path = "";

}

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

}

/*

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

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

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

EditorConsole.setEditor(activeEditor);

}

protected int[] nextEditorLocation() {

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

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

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

if (activeEditor == null) {

// If no current active editor, use default placement

return new int[] {

(screen.width - defaultWidth) / 2,

(screen.height - defaultHeight) / 2,

defaultWidth, defaultHeight, 0

};

} else {

// 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 = editors.get(editors.size() - 1);

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 String 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 = 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) {

// 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 null;

}

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

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

new FileOutputStream(newbieFile); // create the file

return newbieFile.getAbsolutePath();

}

/**

public void handleNew() {

try {

String path = createNewUntitled();

if (path != null) {

Editor editor = handleOpen(path);

editor.untitled = 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 {

String path = createNewUntitled();

if (path != null) {

activeEditor.handleOpenInternal(path);

activeEditor.untitled = true;

}

} catch (IOException e) {

activeEditor.statusError(e);

}

}

/**

public void handleOpenReplace(String path) {

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

if (!loaded) {

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

handleNewReplaceImpl();

}

}

/**

public void handleOpenPrompt() {

// get the frontmost window frame for placing file dialog

FileDialog fd = new FileDialog(activeEditor,

_("Open an Arduino sketch..."),

FileDialog.LOAD);

// This was annoying people, so disabled it in 0125.

//fd.setDirectory(Preferences.get("sketchbook.path"));

//fd.setDirectory(getSketchbookPath());

// Only show .pde files as eligible bachelors

fd.setFilenameFilter(new FilenameFilter() {

public boolean accept(File dir, String name) {

// TODO this doesn't seem to ever be used. AWESOME.

//System.out.println("check filter on " + dir + " " + 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);

handleOpen(inputFile.getAbsolutePath());

}

/**

public Editor handleOpen(String path) {

return handleOpen(path, nextEditorLocation());

}

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

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) {

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

editor.toFront();

return editor;

}

}

// If the active editor window is an untitled, and un-modified document,

// just replace it with the file that's being opened.

Editor editor = new Editor(this, path, location);

// Make sure that the sketch actually loaded

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

return null; // Just walk away quietly

}

editors.add(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;

}

/**

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) {

// For 0158, when closing the last window /and/ it was already an

// untitled sketch, just give up and let the user quit.

if (Base.isMacOS()) {

Object[] options = { "OK", "Cancel" };

String prompt =

_("<html> " +

"<head> <style type=\"text/css\">"+

"b { font: 13pt \"Lucida Grande\" }"+

"p { font: 11pt \"Lucida Grande\"; margin-top: 8px }"+

"</style> </head>" +

"<b>Are you sure you want to Quit?</b>" +

"<p>Closing the last open sketch will quit Arduino.");

int result = JOptionPane.showOptionDialog(editor,

prompt,

_("Quit"),

JOptionPane.YES_NO_OPTION,

JOptionPane.QUESTION_MESSAGE,

null,

options,

options[0]);

if (result == JOptionPane.NO_OPTION ||

result == JOptionPane.CLOSED_OPTION) {

return false;

}

}

// This will store the sketch count as zero

editors.remove(editor);

Editor.serialMonitor.closeSerialPort();

storeSketches();

// Save out the current prefs state

Preferences.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;

}

/**

public boolean handleQuit() {

// If quit is canceled, this will be replaced anyway

// by a later handleQuit() that is not canceled.

storeSketches();

Editor.serialMonitor.closeSerialPort();

if (handleQuitEach()) {

// make sure running sketches close before quitting

for (Editor editor : editors) {

editor.internalCloseRunner();

}

// Save out the current prefs state

Preferences.save();

if (!Base.isMacOS()) {

// If this was fired from the menu or an AppleEvent (the Finder),

// then Mac OS X will send the terminate signal itself.

System.exit(0);

}

return true;

}

return false;

}

/**

protected boolean handleQuitEach() {

int index = 0;

for (Editor editor : editors) {

if (editor.checkModified()) {

// Update to the new/final sketch path for this fella

storeSketchPath(editor, index);

index++;

} else {

return false;

}

}

return true;

}

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

/**

protected void rebuildSketchbookMenus() {

//System.out.println("async enter");

//new Exception().printStackTrace();

SwingUtilities.invokeLater(new Runnable() {

public void run() {

//System.out.println("starting rebuild");

rebuildSketchbookMenu(Editor.sketchbookMenu);

rebuildToolbarMenu(Editor.toolbarMenu);

//System.out.println("done with rebuild");

}

});

//System.out.println("async exit");

}

protected void rebuildToolbarMenu(JMenu menu) {

JMenuItem item;

menu.removeAll();

//System.out.println("rebuilding toolbar menu");

// Add the single "Open" item

item = Editor.newJMenuItem(_("Open..."), 'O');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

handleOpenPrompt();

}

});

menu.add(item);

menu.addSeparator();

// Add a list of all sketches and subfolders

try {

boolean sketches = addSketches(menu, getSketchbookFolder(), true);

//boolean sketches = addSketches(menu, getSketchbookFolder());

if (sketches) menu.addSeparator();

} catch (IOException e) {

e.printStackTrace();

}

//System.out.println("rebuilding examples menu");

// Add each of the subfolders of examples directly to the menu

try {

boolean found = addSketches(menu, examplesFolder, true);

if (found) menu.addSeparator();

found = addSketches(menu, getSketchbookLibrariesFolder(), true);

if (found) menu.addSeparator();

addSketches(menu, librariesFolder, true);

} catch (IOException e) {

e.printStackTrace();

}

}

protected void rebuildSketchbookMenu(JMenu menu) {

//System.out.println("rebuilding sketchbook menu");

//new Exception().printStackTrace();

try {

menu.removeAll();

addSketches(menu, getSketchbookFolder(), false);

//addSketches(menu, getSketchbookFolder());

} catch (IOException e) {

e.printStackTrace();

}

}

public void rebuildImportMenu(JMenu importMenu) {

//System.out.println("rebuilding import menu");

importMenu.removeAll();

// reset the set of libraries

libraries = new HashSet<File>();

// reset the table mapping imports to libraries

importToLibraryTable = new HashMap<String, File>();

// Add from the "libraries" subfolder in the Processing directory

try {

addLibraries(importMenu, librariesFolder);

} catch (IOException e) {

e.printStackTrace();

}

// Add libraries found in the sketchbook folder

int separatorIndex = importMenu.getItemCount();

try {

File sketchbookLibraries = getSketchbookLibrariesFolder();

boolean found = addLibraries(importMenu, sketchbookLibraries);

if (found) {

JMenuItem contrib = new JMenuItem(_("Contributed"));

contrib.setEnabled(false);

importMenu.insert(contrib, separatorIndex);

importMenu.insertSeparator(separatorIndex);

}

} catch (IOException e) {

e.printStackTrace();

}

}

public void rebuildExamplesMenu(JMenu menu) {

//System.out.println("rebuilding examples menu");

try {

menu.removeAll();

boolean found = addSketches(menu, examplesFolder, false);

if (found) menu.addSeparator();

found = addSketches(menu, getSketchbookLibrariesFolder(), false);

if (found) menu.addSeparator();

addSketches(menu, librariesFolder, false);

} catch (IOException e) {

e.printStackTrace();

}

}

public void onBoardOrPortChange() {

for (Editor editor : editors) {

editor.onBoardOrPortChange();

}

}