{

// Backup previous corrupt settings file, so users can fix if they want to

auto const corruptSettings = getInstance()->settingsFile;

auto backupLocation = corruptSettings.getParentDirectory().getChildFile(".settings_damaged").getFullPathName();

int counter = 1;

// Increment backup settings file name if previous exists

while (File(backupLocation).existsAsFile()) {

backupLocation = corruptSettings.getParentDirectory().getChildFile(".settings_damaged_" + String(counter)).getFullPathName();

counter++;

}

backupSettingsLocation = backupLocation;

corruptSettings.moveFileTo(backupLocation);

{

// Basic settings file verification

// Verify if the xml is valid, and tags match correct name / order

// Adjust tags here if future layout changes

if (xml == nullptr || xml->getTagName() != "SettingsTree")

return false;

// These must at least be present in a valid save file!

StringArray expectedNames = {

"Paths",

"KeyMap",

"ColourThemes",

"SelectedThemes",

"RecentlyOpened",

"Libraries",

"Overlays"

};

StringArray const optionalNames {

"HeavyState",

"LastBrowserPaths",

"CommandHistory",

"EnabledMidiInputPorts",

"EnabledMidiOutputPorts"

};

// Check if all expected elements are present and in the correct order

bool unexpectedName = false;

for (auto const* child = xml->getFirstChildElement(); child != nullptr; child = child->getNextElement()) {

auto name = child->getTagName();

if (expectedNames.contains(name)) {

expectedNames.removeString(name);

} else if (!optionalNames.contains(name)) {

std::cerr << "Unexpected settings file entry: " << name << std::endl;

unexpectedName = true;

}

}

for (auto const& expectedName : expectedNames) {

std::cerr << "Expected settings file entry not found: " << expectedName << std::endl;

}

// Check if all expected elements were found

return expectedNames.isEmpty() && !unexpectedName;

{

settingsFileWatcher.addFolder(settingsFile.getParentDirectory());

settingsFileWatcher.addListener(this);

{

if (identifier.isEmpty() || !path.exists() || path.isRoot())

return;

settingsTree.getChildWithName("LastBrowserPaths").setProperty(identifier, path.getFullPathName(), nullptr);

{

if (identifier.isEmpty())

return {};

return { settingsTree.getChildWithName("LastBrowserPaths").getProperty(identifier).toString() };

{

// Make sure all the default paths are in place

HeapArray<File> currentPaths;

currentPaths.reserve(10);

auto pathTree = getPathsTree();

// on iOS, the containerisation of apps leads to problems with custom search paths

// So we completely reset them every time

#if JUCE_IOS

pathTree.removeAllChildren(nullptr);

#endif

for (auto child : pathTree) {

currentPaths.add(File(child.getProperty("Path").toString()));

}

for (auto const& path : pd::Library::defaultPaths) {

if (!currentPaths.contains(path)) {

auto pathSubTree = ValueTree("Path");

pathSubTree.setProperty("Path", path.getFullPathName(), nullptr);

pathTree.appendChild(pathSubTree, nullptr);

}

}

// TODO: remove this later. this is to fix a mistake during v0.8.4 development

for (auto child : pathTree) {

if (child.getProperty("Path").toString().contains("Abstractions/Gem")) {

pathTree.removeChild(child, nullptr);

break;

}

}

{

auto commandHistory = settingsTree.getChildWithName("CommandHistory");

if (commandHistory.isValid()) {

commandHistory.removeAllProperties(nullptr);

} else {

commandHistory = ValueTree("CommandHistory");

SettingsFile::getInstance()->getValueTree().appendChild(commandHistory, nullptr);

}

int commandIndex = 0;

for (auto& command : CommandInput::getCommandHistory()) {

// Don't save more than 50 commands

if (commandIndex > 50)

break;

// Set each command as a unique attribute

commandHistory.setProperty("Command" + String(commandIndex), command, nullptr);

commandIndex++;

}

{

auto const commandHistory = settingsTree.getChildWithName("CommandHistory");

if (!commandHistory.isValid()) {

return;

}

StringArray commands;

String lastCommand;

for (int i = 0; i < commandHistory.getNumProperties(); i++) {

auto command = commandHistory.getProperty("Command" + String(i)).toString();

// Filter out duplicate commands (we also do this in CommandInput, but not during loading)

if (lastCommand != command) {

commands.add(command);

lastCommand = command;

}

}

CommandInput::setCommandHistory(commands);

{

auto recentlyOpened = settingsTree.getChildWithName("RecentlyOpened");

auto path = url.getLocalFile().getFullPathName();

if (!recentlyOpened.isValid()) {

recentlyOpened = ValueTree("RecentlyOpened");

SettingsFile::getInstance()->getValueTree().appendChild(recentlyOpened, nullptr);

}

if (recentlyOpened.getChildWithProperty("Path", path).isValid()) {

auto existing = recentlyOpened.getChildWithProperty("Path", path);

existing.setProperty("Time", Time::getCurrentTime().toMilliseconds(), nullptr);

#if JUCE_IOS

auto bookmarkData = url.getBookmarkData();

if(bookmarkData.isNotEmpty()) {

existing.setProperty("Bookmark", bookmarkData, nullptr);

}

#endif

int const oldIdx = recentlyOpened.indexOf(existing);

recentlyOpened.moveChild(oldIdx, 0, nullptr);

} else {

ValueTree subTree("Path");

subTree.setProperty("Path", path, nullptr);

subTree.setProperty("Time", Time::getCurrentTime().toMilliseconds(), nullptr);

#if JUCE_IOS

// Store iOS bookmark so that we can recover file permissions later

auto bookmarkData = url.getBookmarkData();

if(bookmarkData.isNotEmpty()) {

subTree.setProperty("Bookmark", bookmarkData, nullptr);

}

#endif

#if JUCE_MAC || JUCE_WINDOWS

if (url.getLocalFile().isOnRemovableDrive())

subTree.setProperty("Removable", var(1), nullptr);

#endif

recentlyOpened.addChild(subTree, 0, nullptr);

}

while (recentlyOpened.getNumChildren() > 15) {

auto minTime = Time::getCurrentTime().toMilliseconds();

int minIdx = -1;

// Find oldest entry

for (int i = 0; i < recentlyOpened.getNumChildren(); i++) {

auto child = recentlyOpened.getChild(i);

auto const pinned = child.hasProperty("Pinned") && static_cast<bool>(child.getProperty("Pinned"));

auto const time = static_cast<int64>(child.getProperty("Time"));

if (time < minTime && !pinned) {

minIdx = i;

minTime = time;

}

}

recentlyOpened.removeChild(minIdx, nullptr);

}

// If we do this inside a plugin, it will add to the DAW's recently opened list!

if (ProjectInfo::isStandalone) {

RecentlyOpenedFilesList::registerRecentFileNatively(path);

}

{

if (ProjectInfo::isStandalone) {

return true;

}

if (!settingsTree.hasProperty("NativeDialog")) {

return true;

}

return settingsTree.getProperty("NativeDialog");

{

// Initialise selected themes tree

auto selectedThemes = getSelectedThemesTree();

if (!selectedThemes.hasProperty("first"))

selectedThemes.setProperty("first", "light", nullptr);

if (!selectedThemes.hasProperty("second"))

selectedThemes.setProperty("second", "dark", nullptr);

if (selectedThemes.getProperty("first").toString() != getProperty<String>("theme") && selectedThemes.getProperty("second").toString() != getProperty<String>("theme")) {

setProperty("theme", selectedThemes.getProperty("first").toString());

}

PlugDataLook::selectedThemes.set(0, selectedThemes.getProperty("first").toString());

PlugDataLook::selectedThemes.set(1, selectedThemes.getProperty("second").toString());

auto const defaultColourThemesTree = ValueTree::fromXml(PlugDataLook::defaultThemesXml);

auto colourThemesTree = getColourThemesTree();

if (colourThemesTree.getNumChildren() == 0) {

colourThemesTree.copyPropertiesAndChildrenFrom(defaultColourThemesTree, nullptr);

} else {

// Check if all the default themes are still there

// Mostly for updating from v0.6.3 -> v0.7.0

for (auto themeTree : defaultColourThemesTree) {

if (!colourThemesTree.getChildWithProperty("theme", themeTree.getProperty("theme")).isValid()) {

colourThemesTree.appendChild(themeTree.createCopy(), nullptr);

}

}

// Ensure each theme is valid

for (auto themeTree : colourThemesTree) {

auto themeName = themeTree.getProperty("theme");

// If it's one of the default themes, validate it against the default theme tree

if (defaultColourThemesTree.getChildWithProperty("theme", themeName).isValid()) {

auto defaultTree = defaultColourThemesTree.getChildWithProperty("theme", themeName);

for (auto const& [colourId, colourInfo] : PlugDataColourNames) {

auto& [cId, colourName, colourCategory] = colourInfo;

// For when we add new colours in the future

if (!themeTree.hasProperty(colourName) || themeTree.getProperty(colourName).toString().isEmpty() || themeTree.getProperty(colourName).toString() == "00000000") {

themeTree.setProperty(colourName, defaultTree.getProperty(colourName).toString(), nullptr);

}

}

if (!themeTree.hasProperty("straight_connections")) {

themeTree.setProperty("straight_connections", defaultTree.getProperty("straight_connections"), nullptr);

}

if (!themeTree.hasProperty("connection_style")) {

themeTree.setProperty("connection_style", defaultTree.getProperty("connection_style"), nullptr);

}

if (!themeTree.hasProperty("square_iolets")) {

themeTree.setProperty("square_iolets", defaultTree.getProperty("square_iolets"), nullptr);

}

if (!themeTree.hasProperty("square_object_corners")) {

themeTree.setProperty("square_object_corners", defaultTree.getProperty("square_object_corners"), nullptr);

}

if (!themeTree.hasProperty("object_flag_outlined")) {

themeTree.setProperty("object_flag_outlined", defaultTree.getProperty("object_flag_outlined"), nullptr);

}

if (!themeTree.hasProperty("iolet_spacing_edge")) {

themeTree.setProperty("iolet_spacing_edge", defaultTree.getProperty("iolet_spacing_edge"), nullptr);

}

if (!themeTree.hasProperty("highlight_syntax")) {

themeTree.setProperty("highlight_syntax", defaultTree.getProperty("highlight_syntax"), nullptr);

}

}

// Otherwise, just ensure these properties exist

else {

if (!themeTree.hasProperty("straight_connections")) {

themeTree.setProperty("straight_connections", false, nullptr);

}

if (!themeTree.hasProperty("connection_style")) {

themeTree.setProperty("connection_style", String(1), nullptr);

}

if (!themeTree.hasProperty("square_iolets")) {

themeTree.setProperty("square_iolets", false, nullptr);

}

if (!themeTree.hasProperty("square_object_corners")) {

themeTree.setProperty("square_object_corners", false, nullptr);

}

if (!themeTree.hasProperty("object_flag_outlined")) {

themeTree.setProperty("object_flag_outlined", false, nullptr);

}

if (!themeTree.hasProperty("iolet_spacing_edge")) {

themeTree.setProperty("iolet_spacing_edge", false, nullptr);

}

if (!themeTree.hasProperty("highlight_syntax")) {

themeTree.setProperty("highlight_syntax", true, nullptr);

}

}

}

}

{

UnorderedMap<String, int> defaults = {

{ "edit", Origin | ActivationState },

{ "lock", Behind },

{ "run", None },

{ "alt", Origin | Border | ActivationState | Index | Coordinate | Order | Direction }

};

auto overlayTree = settingsTree.getChildWithName("Overlays");

if (!overlayTree.isValid()) {

overlayTree = ValueTree("Overlays");

for (auto& [name, settings] : defaults) {

overlayTree.setProperty(name, settings, nullptr);

}

settingsTree.appendChild(overlayTree, nullptr);

}

{

auto const startTime = Time::getCurrentTime().toMilliseconds();

while (Time::getCurrentTime().toMilliseconds() - startTime < lockTimeoutMs) {

if (!lockFile.exists()) {

// Try to create lock file with our process info

auto processInfo = String(Time::getCurrentTime().toMilliseconds());

if (lockFile.replaceWithText(processInfo)) {

// Double-check we successfully created it (atomic operation)

Thread::sleep(1); // Brief pause to ensure file system consistency

if (lockFile.exists() && lockFile.loadFileAsString() == processInfo) {

return true;

}

}

} else {

auto lockAge = Time::getCurrentTime().toMilliseconds() - lockFile.loadFileAsString().getLargeIntValue();

if (lockAge > lockTimeoutMs * 2) {

lockFile.deleteFile();

continue; // Try to acquire again

}

}

Thread::sleep(10); // Brief wait before retry

}

return false; // Timeout

{

jassert(isInitialised);

if (acquireFileLock()) {

auto const newSettings = settingsFile.loadFileAsString();

auto const contentHash = newSettings.hashCode64();

if (contentHash == lastContentHash) {

releaseFileLock();

return;

}

auto const newTree = ValueTree::fromXml(newSettings);

if (!newTree.isValid()) {

releaseFileLock();

return;

}

// Children shouldn't be overwritten as that would break some valueTree links

for (auto child : settingsTree) {

child.copyPropertiesAndChildrenFrom(newTree.getChildWithName(child.getType()), nullptr);

}

settingsTree.copyPropertiesFrom(newTree, nullptr);

for (auto* listener : listeners) {

listener->settingsFileReloaded();

}

lastContentHash = contentHash;

releaseFileLock();

}

{

if (file == settingsFile) {

reloadSettings();

}

{

for (auto* listener : listeners) {

listener->settingsChanged(property.toString(), treeWhosePropertyHasChanged.getProperty(property));

}

startTimer(saveTimeoutMs);

{

jassert(isInitialised);

// Save settings to file whenever valuetree state changes

// Use timer to group changes together

saveSettings();

stopTimer();

{

setProperty("global_scale", newScale);

Desktop::getInstance().setGlobalScaleFactor(newScale);

{

jassert(isInitialised);

saveCommandHistory();

// Check if content actually changed

auto const xml = settingsTree.toXmlString();

auto const contentHash = xml.hashCode64();

if (contentHash == lastContentHash) {

return; // No changes to save

}

// Attempt to acquire file lock

if (acquireFileLock()) {

if (settingsFile.replaceWithText(xml)) {

lastContentHash = contentHash;

}

releaseFileLock();

}

{

jassert(isInitialised);

settingsTree.setProperty(name, value, nullptr);

{

jassert(isInitialised);

return settingsTree.hasProperty(name);

{

jassert(isInitialised);

return settingsTree.getPropertyAsValue(name, nullptr);