/*

* This file is part of NodeBox.

*

* Copyright (C) 2008 Frederik De Bleser (frederik@pandora.be)

*

* NodeBox is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* NodeBox 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 NodeBox. If not, see <http://www.gnu.org/licenses/>.

*/

package nodebox.client;

import nodebox.node.NodeLibrary;

import nodebox.node.NodeLibraryManager;

import nodebox.versioncheck.Host;

import nodebox.versioncheck.Updater;

import nodebox.versioncheck.Version;

import javax.swing.*;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Properties;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.logging.Level;

import java.util.logging.Logger;

import java.util.prefs.Preferences;

public class Application implements Host {

private static Application instance;

private JFrame hiddenFrame;

public static Application getInstance() {

return instance;

}

private AtomicBoolean startingUp = new AtomicBoolean(true);

private SwingWorker<Throwable, String> startupWorker;

private Updater updater;

private List<NodeBoxDocument> documents = new ArrayList<NodeBoxDocument>();

private NodeBoxDocument currentDocument;

private NodeLibraryManager manager;

private ProgressDialog startupDialog;

private Version version;

private List<File> filesToLoad = Collections.synchronizedList(new ArrayList<File>());

private Console console = null;

public static final String NAME = "NodeBox";

private static Logger logger = Logger.getLogger("nodebox.client.Application");

private Application() {

instance = this;

initLastResortHandler();

initLookAndFeel();

}

//// Application Load ////

/**

* Starts a SwingWorker that loads the application in the background.

* <p/>

* Called in the event dispatch thread using invokeLater.

*/

private void run() {

showProgressDialog();

startupWorker = new SwingWorker<Throwable, String>() {

@Override

protected Throwable doInBackground() throws Exception {

try {

publish("Starting NodeBox");

setNodeBoxVersion();

createNodeBoxDataDirectories();

applyPreferences();

registerForMacOSXEvents();

updater = new Updater(Application.this);

updater.checkForUpdatesInBackground();

publish("Loading Python");

initPython();

} catch (RuntimeException ex) {

return ex;

}

return null;

}

@Override

protected void process(List<String> strings) {

final String firstString = strings.get(0);

startupDialog.setMessage(firstString);

}

@Override

protected void done() {

startingUp.set(false);

startupDialog.setVisible(false);

// See if application startup has generated an exception.

Throwable t;

try {

t = get();

} catch (Exception e) {

t = e;

}

if (t != null) {

ExceptionDialog ed = new ExceptionDialog(null, t);

ed.setVisible(true);

System.exit(-1);

}

if (documents.isEmpty() && filesToLoad.isEmpty()) {

instance.createNewDocument();

} else {

for (File f : filesToLoad) {

openDocument(f);

}

}

}

};

startupWorker.execute();

}

/**

* Sets a handler for uncaught exceptions that pops up a message dialog with the exception.

* <p/>

* Called from the constructor, in the main thread.

*/

private void initLastResortHandler() {

Thread.currentThread().setUncaughtExceptionHandler(new LastResortHandler());

}

/**

* Initializes Swing's look and feel to the system native look and feel.

* On Mac, uses the system menu bar.

*/

private void initLookAndFeel() {

try {

UIManager.setLookAndFeel(

UIManager.getSystemLookAndFeelClassName());

} catch (Exception ignored) {

}

System.setProperty("apple.laf.useScreenMenuBar", "true");

}

/**

* Shows the progress dialog.

* <p/>

* Called from the run() method (which is called in invokeLater).

*/

private void showProgressDialog() {

startupDialog = new ProgressDialog(null, "Starting " + NAME);

startupDialog.setVisible(true);

}

/**

* Retrieves the NodeBox version number from the version.properties file and sets it in the app.

*

* @throws RuntimeException if we're not able to retrieve the version number. This is fatal.

*/

private void setNodeBoxVersion() throws RuntimeException {

Properties properties = new Properties();

try {

properties.load(new FileInputStream("version.properties"));

version = new Version(properties.getProperty("nodebox.version"));

} catch (IOException e) {

throw new RuntimeException("Could not read NodeBox version file. Please re-install NodeBox.", e);

}

}

/**

* Creates the necessary directories used for storing user scripts and Python libraries.

*

* @throws RuntimeException if we can't create the user directories. This is fatal.

*/

private void createNodeBoxDataDirectories() throws RuntimeException {

PlatformUtils.getUserDataDirectory().mkdir();

PlatformUtils.getUserScriptsDirectory().mkdir();

PlatformUtils.getUserPythonDirectory().mkdir();

}

/**

* Load the preferences and make them available to the Application object.

*/

private void applyPreferences() {

Preferences preferences = Preferences.userNodeForPackage(this.getClass());

// There are no more preferences. Leaving this in for when there are.

}

/**

* Register for special events available on the Mac, such as showing the about screen,

* showing the preferences or double-clicking a file.

*

* @throws RuntimeException if the adapter methods could not be loaded.

*/

private void registerForMacOSXEvents() throws RuntimeException {

if (!PlatformUtils.onMac()) return;

try {

// Generate and register the OSXAdapter, passing it a hash of all the methods we wish to

// use as delegates for various com.apple.eawt.ApplicationListener methods

OSXAdapter.setQuitHandler(this, getClass().getDeclaredMethod("quit", (Class[]) null));

OSXAdapter.setAboutHandler(this, getClass().getDeclaredMethod("showAbout", (Class[]) null));

OSXAdapter.setPreferencesHandler(this, getClass().getDeclaredMethod("showPreferences", (Class[]) null));

OSXAdapter.setFileHandler(this, getClass().getDeclaredMethod("readFromFile", String.class));

} catch (Exception e) {

throw new RuntimeException("Error while loading the OS X Adapter.", e);

}

// On the Mac, if all windows are closed the menu bar will be empty.

// To solve this, we create an off-screen window with the same menu bar as visible windows.

hiddenFrame = new JFrame();

hiddenFrame.setJMenuBar(new NodeBoxMenuBar());

hiddenFrame.setUndecorated(true);

hiddenFrame.setSize(0, 0);

hiddenFrame.setLocation(-100, -100);

hiddenFrame.pack();

hiddenFrame.setVisible(true);

}

private void initPython() {

manager = new NodeLibraryManager();

manager.addSearchPath(PlatformUtils.getApplicationScriptsDirectory());

manager.addSearchPath(PlatformUtils.getUserScriptsDirectory());

manager.lookForLibraries();

PythonUtils.initializePython();

}

//// Application events ////

public boolean quit() {

// Because documents will disappear from the list once they are closed,

// make a copy of the list.

java.util.List<NodeBoxDocument> documents = new ArrayList<NodeBoxDocument>(getDocuments());

for (NodeBoxDocument d : documents) {

if (!d.close())

return false;

}

System.exit(0);

return true;

}

public void showAbout() {

String javaVersion = System.getProperty("java.runtime.version");

JOptionPane.showMessageDialog(null, NAME + " version " + getVersion() + "\nJava " + javaVersion, NAME, JOptionPane.INFORMATION_MESSAGE);

}

public void showPreferences() {

PreferencesDialog dialog = new PreferencesDialog();

dialog.setModal(true);

dialog.setVisible(true);

}

public void showConsole() {

java.awt.Dimension d = new java.awt.Dimension(400, 400);

if (console == null) {

console = new Console();

console.setPreferredSize(d);

console.setSize(d);

console.setLocationRelativeTo(getCurrentDocument());

console.setVisible(true);

}

console.setLocationRelativeTo(getCurrentDocument());

console.setVisible(true);

for (NodeBoxDocument document : documents) {

document.onConsoleVisibleEvent(true);

}

}

public void hideConsole() {

console.setVisible(false);

onHideConsole();

}

public void onHideConsole() {

for (NodeBoxDocument document : documents) {

document.onConsoleVisibleEvent(false);

}

}

public boolean isConsoleOpened() {

if (console == null) return false;

return console.isVisible();

}

public void readFromFile(String path) {

// This method looks unused, but is actually called using reflection by the OS X adapter.

// If the application is still starting up, don't open the document immediately but place it in a file loading queue.

if (startingUp.get()) {

filesToLoad.add(new File(path));

} else {

openDocument(new File(path));

}

}

//// Document management ////

public List<NodeBoxDocument> getDocuments() {

return documents;

}

public int getDocumentCount() {

return documents.size();

}

public void removeDocument(NodeBoxDocument document) {

documents.remove(document);

}

public NodeBoxDocument createNewDocument() {

NodeLibrary newLibrary = new NodeLibrary("untitled");

NodeBoxDocument doc = new NodeBoxDocument(newLibrary);

addDocument(doc);

return doc;

}

public boolean openDocument(File file) {

// Check if the document is already open.

String path;

try {

path = file.getCanonicalPath();

for (NodeBoxDocument doc : Application.getInstance().getDocuments()) {

try {

if (doc.getDocumentFile() == null) continue;

if (doc.getDocumentFile().getCanonicalPath().equals(path)) {

// The document is already open. Bring it to the front.

doc.toFront();

doc.requestFocus();

NodeBoxMenuBar.addRecentFile(file);

return true;

}

} catch (IOException e) {

logger.log(Level.WARNING, "The document " + doc.getDocumentFile() + " refers to path with errors", e);

}

}

} catch (IOException e) {

logger.log(Level.WARNING, "The document " + file + " refers to path with errors", e);

}

try {

NodeBoxDocument doc = new NodeBoxDocument(file);

addDocument(doc);

NodeBoxMenuBar.addRecentFile(file);

return true;

} catch (RuntimeException e) {

logger.log(Level.SEVERE, "Error while loading " + file, e);

ExceptionDialog d = new ExceptionDialog(null, e);

d.setVisible(true);

return false;

}

}

private void addDocument(NodeBoxDocument doc) {

doc.setVisible(true);

doc.requestFocus();

documents.add(doc);

currentDocument = doc;

}

public NodeBoxDocument getCurrentDocument() {

return currentDocument;

}

void setCurrentDocument(NodeBoxDocument document) {

currentDocument = document;

}

public NodeLibraryManager getManager() {

return manager;

}

//// Host implementation ////

public String getName() {

return "NodeBox";

}

public String getIconFile() {

return "res/applogo.png";

}

public Version getVersion() {

return version;

}

public String getAppcastURL() {

return "https://secure.nodebox.net/app/nodebox/appcast.xml";

}

public Updater getUpdater() {

return updater;

}

public static void main(String[] args) {

final Application app = new Application();

SwingUtilities.invokeLater(new Runnable() {

public void run() {

app.run();

}

});

}

}