Skip to content
Open
229 changes: 39 additions & 190 deletions app/src/processing/app/Preferences.java
Original file line number Diff line number Diff line change
Expand Up @@ -23,62 +23,36 @@

import processing.app.ui.Toolkit;
import processing.core.PApplet;
import processing.core.PConstants;

import java.awt.*;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.awt.Color;
import java.awt.Font;
import java.awt.SystemColor;
import java.io.IOException;
import java.io.InputStream;


/**
* Storage class for user preferences and environment settings.
* <P>
* This class does not use the Properties class because .properties files use
* ISO 8859-1 encoding, which is highly likely to be a problem when trying to
* save sketch folders and locations. Like the rest of Processing, we use UTF8.
* <p>
* We don't use the Java Preferences API because it would entail writing to
* the registry (on Windows), or an obscure file location (on Mac OS X) and
* make it far more difficult (impossible) to remove the preferences.txt to
* reset them (when they become corrupt), or to find the the file to make
* edits for numerous obscure preferences that are not part of the preferences
* window. If we added a generic editor (e.g. about:config in Mozilla) for
* such things, we could start using the Java Preferences API. But wow, that
* sounds like a lot of work. Not unlike writing this paragraph.
* The app-facing side of the preferences. The actual storage (loading and
* saving preferences.txt, the bundled defaults, platform-specific keys)
* lives in the standalone {@link processing.utils.Preferences}; this class
* delegates to it and keeps the pieces that only make sense inside the
* full application: fonts and colors, error dialogs, and environment
* side effects like proxies and the native file chooser.
*/
public class Preferences {
// had to rename the defaults file because people were editing it
static final String DEFAULTS_FILE = "defaults.txt"; //$NON-NLS-1$
static final String PREFS_FILE = "preferences.txt"; //$NON-NLS-1$

static Map<String, String> defaults;
static Map<String, String> table = new HashMap<>();
static File preferencesFile;
private static boolean initialized = false;


// /** @return true if the sketchbook file did not exist */
// static public boolean init() {
static public void init() {
initialized = true;
// start by loading the defaults, in case something
// important was deleted from the user prefs
try {
var defaultsStream = Preferences
.class
.getClassLoader()
.getResourceAsStream(DEFAULTS_FILE);
load(defaultsStream);
} catch (Exception e) {
processing.utils.Preferences.loadDefaults();
} catch (IOException e) {
Messages.showError(null, "Could not read default settings.\n" +
"You'll need to reinstall Processing.", e);
}

// Clone the defaults, then override any them with the user's preferences.
// This ensures that any new/added preference will be present.
defaults = new HashMap<>(table);

// other things that have to be set explicitly for the defaults
setColor("run.window.bgcolor", SystemColor.control); //$NON-NLS-1$

Expand All @@ -87,29 +61,20 @@ static public void init() {
setBoolean("editor.input_method_support", true);
}


// next load user preferences file
preferencesFile = Base.getSettingsFile(PREFS_FILE);
var preferencesFileOverride = System.getProperty("processing.app.preferences.file");
if (preferencesFileOverride != null && !preferencesFileOverride.isEmpty()) {
preferencesFile = new File(preferencesFileOverride);
}
boolean firstRun = !preferencesFile.exists();
if (!firstRun) {
try {
load(new FileInputStream(preferencesFile));

} catch (Exception ex) {
Messages.showError("Error reading preferences",
"Error reading the preferences file. " +
"Please delete (or move)\n" +
preferencesFile.getAbsolutePath() +
" and restart Processing.", ex);
}
// next load user preferences file over the defaults
boolean needsSave = false;
try {
needsSave =
processing.utils.Preferences.loadUserPrefs(Base.getSettingsFolder());
} catch (IOException ex) {
Messages.showError("Error reading preferences",
"Error reading the preferences file. " +
"Please delete (or move)\n" +
processing.utils.Preferences.getPreferencesPath() +
" and restart Processing.", ex);
}

if (checkSketchbookPref() || firstRun) {
// if (firstRun) {
if (needsSave) {
// create a new preferences file if none exists
// saves the defaults out to the file
save();
Expand Down Expand Up @@ -140,15 +105,15 @@ static public void init() {
* For testing, pretend to load preferences without a real file.
*/
static public void skipInit() {
initialized = true;
processing.utils.Preferences.skipInit();
}

/**
* Check whether Preferences.init() has been called. If not, we are probably not running the full application.
* @return true if Preferences has been initialized
*/
static public boolean isInitialized() {
return initialized;
return processing.utils.Preferences.isInitialized();
}


Expand All @@ -165,120 +130,24 @@ static void handleProxy(String protocol, String hostProp, String portProp) {


static public String getPreferencesPath() {
return preferencesFile.getAbsolutePath();
return processing.utils.Preferences.getPreferencesPath();
}


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


/**
* Load a set of key/value pairs from a UTF-8 encoded file into 'table'.
* For 3.0a6, this removes any platform-specific extensions from keys, so
* that we don't have platform-specific entries in a user's preferences.txt
* file, which would require all prefs to be changed twice, or risk being
* overwritten by the unchanged platform-specific version on reload.
*/
static public void load(InputStream input) throws IOException {
HashMap<String, String> platformSpecific = new HashMap<>();

String[] lines = PApplet.loadStrings(input); // Reads as UTF-8
for (String line : lines) {
if ((line.isEmpty()) ||
(line.charAt(0) == '#')) continue;

line = line.replace("\\", "/"); // normalize slashes in paths

// this won't properly handle = signs being in the text
int equals = line.indexOf('=');
if (equals != -1) {
String key = line.substring(0, equals).trim();
String value = line.substring(equals + 1).trim();
if (!isPlatformSpecific(key, value, platformSpecific)) {
table.put(key, value);
}
}
}
// Now override the keys with any platform-specific defaults we've found.
for (String key : platformSpecific.keySet()) {
table.put(key, platformSpecific.get(key));
}

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

was this moved somewhere? or just deleted?

processing.utils.Preferences.load(input);
}


/**
* @param key original key (may include platform extension)
* @param value the value that goes with the key
* @param specific where to put the key/value pairs for *this* platform
* @return true if a platform-specific key
*/
static protected boolean isPlatformSpecific(String key, String value,
Map<String, String> specific) {
for (String platform : PConstants.platformNames) {
String ext = "." + platform;
if (key.endsWith(ext)) {
String thisPlatform = PConstants.platformNames[PApplet.platform];
if (platform.equals(thisPlatform)) {
key = key.substring(0, key.lastIndexOf(ext));
// store this for later overrides
specific.put(key, value);
//} else {
// ignore platform-specific defaults for other platforms,
// but return 'true' because it needn't be added to the big list
}
return true;
}
}
return false;
}


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


static public void save() {
// On startup, this is null, but ignore it. It's trying to update the
// prefs for the open sketch before Preferences.init() has been called.
if (preferencesFile != null) {
try {
File dir = preferencesFile.getParentFile();
File preferencesTemp = File.createTempFile("preferences", ".txt", dir);
if (!preferencesTemp.setWritable(true, false)) {
throw new IOException("Could not set " + preferencesTemp + " writable");
}

// Fix for 0163 to properly use Unicode when writing preferences.txt
PrintWriter writer = PApplet.createWriter(preferencesTemp);

String[] keyList = table.keySet().toArray(new String[0]);
// Sorting is really helpful for debugging, diffing, and finding keys
keyList = PApplet.sort(keyList);
for (String key : keyList) {
writer.println(key + "=" + table.get(key)); //$NON-NLS-1$
}
writer.flush();
writer.close();

// Rename preferences.txt to preferences.old
File oldPreferences = new File(dir, "preferences.old");
if (oldPreferences.exists()) {
if (!oldPreferences.delete()) {
throw new IOException("Could not delete preferences.old");
}
}
if (preferencesFile.exists() &&
!preferencesFile.renameTo(oldPreferences)) {
throw new IOException("Could not replace preferences.old");
}
// Make the temporary file into the real preferences
if (!preferencesTemp.renameTo(preferencesFile)) {
throw new IOException("Could not move preferences file into place");
}

} catch (IOException e) {
Messages.showWarning("Preferences",
"Could not save the Preferences file.", e);
}
try {
processing.utils.Preferences.save();
} catch (IOException e) {
Messages.showWarning("Preferences",
"Could not save the Preferences file.", e);
}
}

Expand All @@ -289,25 +158,25 @@ static public void save() {
// all the information from preferences.txt

static public String get(String attribute /*, String defaultValue */) {
if (!initialized) {
if (!isInitialized()) {
init();
}
return table.get(attribute);
return processing.utils.Preferences.get(attribute);
}


static public String getDefault(String attribute) {
return defaults.get(attribute);
return processing.utils.Preferences.getDefault(attribute);
}


static public void set(String attribute, String value) {
table.put(attribute, value);
processing.utils.Preferences.set(attribute, value);
}


static public void unset(String attribute) {
table.remove(attribute);
processing.utils.Preferences.unset(attribute);
}


Expand Down Expand Up @@ -385,26 +254,6 @@ static public Font getFont(String familyAttr, String sizeAttr, int style) {
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


/**
* Check for a 4.0 sketchbook location, and if none exists,
* try to grab it from the 3.0 sketchbook location.
* @return true if a location was found and the pref didn't exist
*/
static protected boolean checkSketchbookPref() {
// If a 4.0 sketchbook location has never been inited
if (getSketchbookPath() == null) {
String threePath = get("sketchbook.path.three"); //$NON-NLS-1$
// If they've run the 3.0 version, start with that location
if (threePath != null) {
setSketchbookPath(threePath);
return true; // save the sketchbook right away
}
// Otherwise it'll be null, and reset properly by Base
}
return false;
}


static public String getOldSketchbookPath() {
return get("sketchbook.path.three"); //$NON-NLS-1$
}
Expand Down
12 changes: 12 additions & 0 deletions app/utils/src/main/java/processing/utils/Platform.java
Original file line number Diff line number Diff line change
Expand Up @@ -23,4 +23,16 @@ static public boolean isWindows() {
static public boolean isLinux() {
return System.getProperty("os.name").contains("Linux"); //$NON-NLS-1$ //$NON-NLS-2$
}


/**
* Platform name for the current OS, mirroring core's
* PConstants.platformNames: "windows", "macos", "linux", or "other".
*/
static public String getName() {
if (isWindows()) return "windows"; //$NON-NLS-1$
if (isMacOS()) return "macos"; //$NON-NLS-1$
if (isLinux()) return "linux"; //$NON-NLS-1$
return "other"; //$NON-NLS-1$
}
}
Loading
Loading