QStringList values;

if (!j.contains(key) || !j[key].is_array()) return values;

for (const fifojson& value : j[key]) {

if (!value.is_string()) continue;

values.push_back(QString::fromStdString(value.get<std::string>()));

}

return values;

QStringList result;

for (const QString& file : files) {

const QString path = absoluteFilePath(file);

if (path.isEmpty() || !hasSuffix(path, suffixes) || result.contains(path)) continue;

result.push_back(path);

if (result.size() >= kMaxRecentFiles) break;

}

return result;

path = absoluteFilePath(path);

if (path.isEmpty()) return;

files.removeAll(path);

files.prepend(path);

while (files.size() > kMaxRecentFiles) { files.removeLast(); }

fifojson result = fifojson::array();

for (const QString& value : values) { result.push_back(value); }

return result;

// Create static location for gcode output for session

QString appPathStr = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);

QDir appPath(appPathStr);

QString httpAppLocationStr = QDir::temp().absolutePath() + "/http_config";

QDir httpConfigPath(httpAppLocationStr);

try {

if (!appPath.exists()) QDir().mkpath(appPathStr);

if (!httpConfigPath.exists()) QDir().mkpath(httpAppLocationStr);

} catch (...) { qWarning() << "Check your path, cannot create directory:" + appPathStr; }

defaultGcodeFile = appPath.filePath("gcode_output");

loadHistory();

// clear any temp STLs created from http import

appPath.setNameFilters(QStringList() << "*.stl");

appPath.setFilter(QDir::Files);

for (QString tempStls : appPath.entryList()) { appPath.remove(tempStls); }

QDir path = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);

QFile file(path.filePath("app.history"));

if (file.exists()) {

file.open(QIODevice::ReadOnly);

QString history = file.readAll();

fifojson j = json::parse(history.toStdString());

QString defaultLocation = QStandardPaths::writableLocation(QStandardPaths::DesktopLocation);

m_most_recent_setting_history.insert(Constants::Settings::SettingTab::kPrinter,

QString::fromStdString(j.value("printer_setting", "LFAM_03in")));

m_most_recent_setting_history.insert(Constants::Settings::SettingTab::kMaterial,

QString::fromStdString(j.value("material_setting", "LFAM_03in")));

m_most_recent_setting_history.insert(Constants::Settings::SettingTab::kProfile,

QString::fromStdString(j.value("profile_setting", "LFAM_03in")));

m_most_recent_setting_history.insert(Constants::Settings::SettingTab::kExperimental,

QString::fromStdString(j.value("experimental_setting", "LFAM_03in")));

m_most_recent_model_location = j.value("model_location", defaultLocation);

m_most_recent_project_location = j.value("project_location", defaultLocation);

m_most_recent_gcode_location = j.value("gcode_location", defaultLocation);

m_most_recent_setting_folder_location = j.value("setting_folder_location", defaultLocation);

m_most_recent_layer_bar_setting_folder_location = j.value("layer_bar_setting_folder_location", defaultLocation);

m_most_recent_http_config = j.value("http_config", QString());

m_recent_project_files = sanitizedRecentFiles(readStringList(j, "recent_project_files"), {"s2p"});

m_recent_model_files =

sanitizedRecentFiles(readStringList(j, "recent_model_files"), {"stl", "3mf", "obj", "amf", "step", "stp"});

file.close();

}

else {

m_most_recent_setting_history.insert(Constants::Settings::SettingTab::kPrinter, "LFAM_03in");

m_most_recent_setting_history.insert(Constants::Settings::SettingTab::kMaterial, "LFAM_03in");

m_most_recent_setting_history.insert(Constants::Settings::SettingTab::kProfile, "LFAM_03in");

m_most_recent_setting_history.insert(Constants::Settings::SettingTab::kExperimental, "LFAM_03in");

m_most_recent_model_location = m_most_recent_project_location = m_most_recent_gcode_location =

m_most_recent_setting_folder_location = m_most_recent_layer_bar_setting_folder_location =

QStandardPaths::writableLocation(QStandardPaths::DesktopLocation);

m_most_recent_http_config = QString();

m_recent_project_files.clear();

m_recent_model_files.clear();

m_dirty_history = true;

}

if (m_dirty_history) {

fifojson j;

j["printer_setting"] = m_most_recent_setting_history[Constants::Settings::SettingTab::kPrinter];

j["material_setting"] = m_most_recent_setting_history[Constants::Settings::SettingTab::kMaterial];

j["profile_setting"] = m_most_recent_setting_history[Constants::Settings::SettingTab::kProfile];

j["experimental_setting"] = m_most_recent_setting_history[Constants::Settings::SettingTab::kExperimental];

j["model_location"] = m_most_recent_model_location;

j["project_location"] = m_most_recent_project_location;

j["gcode_location"] = m_most_recent_gcode_location;

j["setting_folder_location"] = m_most_recent_setting_folder_location;

j["layer_bar_setting_folder_location"] = m_most_recent_layer_bar_setting_folder_location;

j["http_config"] = m_most_recent_http_config;

j["recent_project_files"] = stringListToJson(m_recent_project_files);

j["recent_model_files"] = stringListToJson(m_recent_model_files);

// Causes segfault if QStandardPaths is referenced here?

// QDir path = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);

QDir path = m_save_dir;

QFile file(path.filePath("app.history"));

file.open(QIODevice::WriteOnly);

file.write(j.dump(4).c_str());

file.close();

m_dirty_history = false;

}

QFileInfo file_info(filename);

if (synchRequired) {

auto meshes = MeshLoader::LoadMeshes(filename, mt, mtrx, PreferencesManager::getInstance()->getImportUnit());

for (auto mesh_data : meshes) {

addPart(mesh_data.mesh, filename, mt);

if (!m_models.contains(file_info.fileName()))

m_models.insert(file_info.fileName(), {mesh_data.raw_data, mesh_data.size});

else

free(mesh_data.raw_data);

}

}

else {

MeshLoader* loader = new MeshLoader(filename, mt, mtrx, PreferencesManager::getInstance()->getImportUnit());

connect(loader, &MeshLoader::finished, loader, &MeshLoader::deleteLater);

connect(loader, &MeshLoader::error, this, [this](QString msg) { emit forwardStatusUpdate(msg); });

connect(loader, &MeshLoader::newMesh, this, [this, filename, file_info, mt](MeshLoader::MeshData mesh_data) {

addPart(mesh_data.mesh, filename, mt);

if (!m_models.contains(file_info.fileName()))

m_models.insert(file_info.fileName(), {mesh_data.raw_data, mesh_data.size});

else

free(mesh_data.raw_data);

});

loader->start();

}

if (saveLocation) {

setMostRecentModelLocation(file_info.absoluteFilePath());

addRecentModelFile(filename, mt);

}

return true;

m_load_mutex.lock();

// Try to find a name for this part.

QString name = new_part->name();

QString org_name = name;

uint count = 1;

while (m_parts.contains(name)) {

name = org_name + "_" + QString::number(count);

count++;

}

new_part->setName(name);

m_parts.insert(name, new_part);

if (notify) emit partAdded(new_part);

m_load_mutex.unlock();

m_load_mutex.lock();

QSharedPointer<Part> new_part = QSharedPointer<Part>::create(new_mesh, filename, mt);

// Try to find a name for this part.

QString file_name;

if (filename == "") // filename is blank because the part is being loaded via project import

{

file_name = new_part->name();

QString org_name = file_name;

uint count = 1;

while (m_parts.contains(file_name)) {

file_name = org_name + "_" + QString::number(count);

count++;

}

}

else // filename exists because the part is being loaded via UI button

{

// Find everything after the last /

QStringList full_name_parts = filename.split("/");

file_name = full_name_parts.at(full_name_parts.size() - 1);

QString orig_file_name = file_name;

// Add a number to duplicated file names

uint count = 1;

while (m_parts.contains(file_name)) {

// Separate at the periods, then join everything before the last period

QStringList orig_file_name_parts = orig_file_name.split(".");

QString name;

for (int i = 0; i < orig_file_name_parts.size() - 1; i++) { name += orig_file_name_parts[i] + "."; }

name.chop(1); // Without this, the file name will always include an extra period

// Add a number to signify a new instance of an existing file name

file_name = name + "_" + QString::number(count);

// Re-add the file extension

file_name += "." + orig_file_name_parts[orig_file_name_parts.size() - 1];

count++;

}

}

new_part->setName(file_name);

m_parts.insert(file_name, new_part);

emit partAdded(new_part);

m_load_mutex.unlock();

QString filename = pm->part()->sourceFilePath();

if (filename.isNull() || filename.isEmpty() || !(QFileInfo(filename).exists() && QFileInfo(filename).isFile())) {

emit forwardStatusUpdate("Part reload failed, file \"" + filename + "\", no such source file available");

return;

}

QFileInfo file_info(filename);

const MeshType mesh_type = pm->part()->getMeshType();

setMostRecentModelLocation(file_info.absoluteFilePath());

addRecentModelFile(filename, mesh_type);

MeshLoader* loader =

new MeshLoader(filename, mesh_type, QMatrix4x4(), PreferencesManager::getInstance()->getImportUnit());

connect(loader, &MeshLoader::finished, loader, &MeshLoader::deleteLater);

connect(loader, &MeshLoader::error, this, [this](QString msg) { emit forwardStatusUpdate(msg); });

connect(loader, &MeshLoader::newMesh, this, [this, file_info, pm](MeshLoader::MeshData mesh_data) {

pm->part()->setRootMesh(mesh_data.mesh);

m_models[file_info.fileName()] = {mesh_data.raw_data, mesh_data.size};

emit partReloaded(pm);

emit forwardStatusUpdate("Reloaded part model, file \"" + file_info.fileName() + "\"");

});

loader->start();

if (filename.isNull() || filename.isEmpty() || !(QFileInfo(filename).exists() && QFileInfo(filename).isFile())) {

emit forwardStatusUpdate("Part reload failed, file \"" + filename + "\", no such source file available");

return;

}

QFileInfo file_info(filename);

const MeshType mesh_type = pm->part()->getMeshType();

setMostRecentModelLocation(file_info.absoluteFilePath());

addRecentModelFile(filename, mesh_type);

MeshLoader* loader =

new MeshLoader(filename, mesh_type, QMatrix4x4(), PreferencesManager::getInstance()->getImportUnit());

connect(loader, &MeshLoader::finished, loader, &MeshLoader::deleteLater);

connect(loader, &MeshLoader::error, this, [this](QString msg) { emit forwardStatusUpdate(msg); });

connect(loader, &MeshLoader::newMesh, this, [this, file_info, pm](MeshLoader::MeshData mesh_data) {

pm->part()->setSourceFile(file_info.fileName());

pm->part()->setRootMesh(mesh_data.mesh);

m_models[file_info.fileName()] = {mesh_data.raw_data, mesh_data.size};

emit partReloaded(pm);

emit forwardStatusUpdate("Reloaded part model, file \"" + file_info.fileName() + "\"");

});

loader->start();

// Try to find a name for this part.

QString name = new_part->name();

QString org_name = name;

uint count = 1;

while (m_parts.contains(name)) {

name = org_name + "_" + QString::number(count);

count++;

}

new_part->setName(name);

m_parts.insert(name, new_part);

if (!m_parts.contains(part->name())) return false;

// Keep the part around for a second so we can emit a removed signal. That way, any object that wants to

// perform some finals operations on the part can still do so.

QSharedPointer<Part> old_part = m_parts[part->name()];

m_parts.remove(old_part->name());

if (m_models.contains(part->rootMesh()->name())) m_models.remove(part->rootMesh()->name());

for (auto& model : part->subMeshes())

if (m_models.contains(model->name())) m_models.remove(model->name());

emit partRemoved(old_part);

return true;

if (!m_parts.contains(name)) return false;

// Keep the part around for a second so we can emit a removed signal. That way, any object that wants to

// perform some finals operations on the part can still do so.

QSharedPointer<Part> old_part = m_parts[name];

m_parts.remove(name);

emit partRemoved(old_part);

return true;

m_parts.clear();

emit partsCleared();

fifojson session_json = fifojson::object();

for (QSharedPointer<Part> curr_part : m_parts) {

fifojson part_json = fifojson::object();

part_json[Constants::Settings::Session::kFile] = curr_part->rootMesh()->path().split("/").back();

part_json[Constants::Settings::Session::kMeshType] = static_cast<int>(curr_part->rootMesh()->type());

part_json[Constants::Settings::Session::kGenType] = static_cast<int>(curr_part->rootMesh()->genType());

part_json[Constants::Settings::Session::kOrgDims]["x"] = curr_part->rootMesh()->originalDimensions().x;

part_json[Constants::Settings::Session::kOrgDims]["y"] = curr_part->rootMesh()->originalDimensions().y;

part_json[Constants::Settings::Session::kOrgDims]["z"] = curr_part->rootMesh()->originalDimensions().z;

part_json[Constants::Settings::Session::kTransforms] = curr_part->rootMesh()->transformations();

session_json[Constants::Settings::Session::kParts][curr_part->name().toStdString()] = part_json;

}

return session_json;

int totalParts = 0;

for (auto it : j[Constants::Settings::Session::kParts].items()) { ++totalParts; }

emit totalPartsInProject(totalParts);

for (auto it : j[Constants::Settings::Session::kParts].items()) {

// Get mesh information

QString name = QString::fromStdString(it.key());

MeshType mesh_type = it.value()[Constants::Settings::Session::kMeshType];

MeshGeneratorType gen_type = it.value()[Constants::Settings::Session::kGenType];

Distance3D org_dims(it.value()[Constants::Settings::Session::kOrgDims]["x"],

it.value()[Constants::Settings::Session::kOrgDims]["y"],

it.value()[Constants::Settings::Session::kOrgDims]["z"]);

auto mtrxesArray = it.value()[Constants::Settings::Session::kTransforms];

int transformCount = 1;

QVector<QMatrix4x4> mtrxes;

if (mtrxesArray.size() == 0) {

QMatrix4x4 mtrx = it.value()[Constants::Settings::Session::kTransform];

mtrxes.append(mtrx);

}

else {

transformCount = (int)mtrxesArray.size();

for (auto i = 0; i < transformCount; i++) {

QMatrix4x4 mx = mtrxesArray[i];

mtrxes.append(mx);

}

}

switch (gen_type) {

case kNone: // Not generated, so load from file

{

QString filename = QString::fromStdString(it.value()[Constants::Settings::Session::kFile]);

if (m_models.contains(filename)) // Allready have this model data

{

auto data = m_models.value(filename);

auto meshes =

MeshLoader::LoadMeshes(filename, mesh_type, mtrxes[0], Distance(mm), data.model, data.size);

for (auto mesh_data : meshes) {

mesh_data.mesh->setTransformations(mtrxes);

mesh_data.mesh->setName(name);

addPart(mesh_data.mesh);

}

}

break;

}

case kRectangularBox: {

auto mesh =

QSharedPointer<ClosedMesh>::create(MeshFactory::CreateBoxMesh(org_dims.x, org_dims.y, org_dims.z));

mesh->setTransformations(mtrxes);

mesh->setType(mesh_type);

mesh->setName(name);

CSM->addPart(mesh);

break;

}

case kTriangularPyramid: {

auto mesh = QSharedPointer<ClosedMesh>::create(MeshFactory::CreateTriaglePyramidMesh(org_dims.y));

mesh->setTransformations(mtrxes);

mesh->setType(mesh_type);

mesh->setName(name);

CSM->addPart(mesh);

break;

}

case kHexagonalPrism: {

auto mesh = QSharedPointer<ClosedMesh>::create(

MeshFactory::CreateHexagonalPrismMesh(org_dims.x / 2.0, org_dims.z));

mesh->setTransformations(mtrxes);

mesh->setType(mesh_type);

mesh->setName(name);

CSM->addPart(mesh);

break;

}

case kCylinder: {

auto mesh = QSharedPointer<ClosedMesh>::create(MeshFactory::CreateCylinderMesh(org_dims.y, org_dims.z));

mesh->setTransformations(mtrxes);

mesh->setType(mesh_type);

mesh->setName(name);

CSM->addPart(mesh);

break;

}

case kCone: {

auto mesh = QSharedPointer<ClosedMesh>::create(MeshFactory::CreateConeMesh(org_dims.y, org_dims.z));

mesh->setTransformations(mtrxes);

mesh->setType(mesh_type);

mesh->setName(name);

CSM->addPart(mesh);

break;

}

case kOpenTopBox:

case kDefaultSettingRegion: {

auto mesh = QSharedPointer<OpenMesh>::create(

MeshFactory::CreateOpenTopBoxMesh(org_dims.x, org_dims.y, org_dims.z));

mesh->setTransformations(mtrxes);

mesh->setType(mesh_type);

mesh->setName(name);

CSM->addPart(mesh);

break;

}

};

}

return true;

for (auto part : m_parts) {

if (part->getMeshType() == MeshType::kBuild) return true;

}

return false;

const GcodeSyntax syntax = GSM->getGlobal()->setting<GcodeSyntax>(PRS::MachineSetup::kSyntax);

const SlicingMode type = static_cast<SlicingMode>(GSM->getGlobal()->setting<int>(PS::Slicing::kSlicingMode));

if (type == SlicingMode::kCylindrical && !supportsCylindricalSlicing(syntax)) {

const QString message = "Cylindrical slicing requires Printer > Machine Setup > Syntax to be Arc Specialties.";

qWarning() << message;

emit forwardStatusUpdate(message);

return false;

}

// check current syntax for file suffix that needs to be output

tempGcodeFile = defaultGcodeFile + GcodeMetaList::SyntaxToMetaHash[(int)syntax].m_file_suffix;

m_sensor_files_generated = GSM->getGlobal()->setting<bool>(PS::LaserScanner::kLaserScanner);

if (m_ast.isNull())

this->changeSlicer(type);

else {

// See if it has changed

if (m_slicing_mode != type)

this->changeSlicer(type);

else

m_ast->setGcodeOutput(tempGcodeFile);

}

// Request new information about the parts to be sliced.

emit requestTransformationUpdate();

emit startSlice();

return true;

Diagnostics::logLine(QString("SessionManager slice complete: %1").arg(tempGcodeFile));

emit forwardSliceComplete(tempGcodeFile, true);

return true;

QSharedPointer<Part> new_copy = QSharedPointer<Part>(new Part(*m_copied_part));

// reset transforms so that part matches it's original as loaded (graphical manipulations still apply)

new_copy->setTransformation(QMatrix4x4());

QString name = new_copy->name();

QString org_name = name = name.left(name.lastIndexOf('_'));

uint count = 1;

// Try to find a name for this part.

while (m_parts.contains(name)) {

name = org_name + "_" + QString::number(count);

count++;

}

new_copy->rootMesh()->setName(name);

m_load_mutex.lock();

m_parts.insert(name, new_copy);

emit partAdded(new_copy);

m_load_mutex.unlock();

if (m_ast.isNull()) { return 0; }

return m_ast->getTimeElapsed();

// Disconnect the signals from the AST.

QObject::disconnect(this, &SessionManager::startSlice, nullptr, nullptr);

// Reset the AST with a new slicer.

switch (type) {

case SlicingMode::kPlanar:

m_ast.reset(new PlanarSlicer(tempGcodeFile));

break;

case SlicingMode::kImage:

m_ast.reset(new ImageSlicer(tempGcodeFile));

break;

case SlicingMode::kCylindrical:

m_ast.reset(new CylindricalSlicer(tempGcodeFile));

break;

default:

qWarning() << "Unknown slicing mode requested. Falling back to Planar slicer.";

m_ast.reset(new PlanarSlicer(tempGcodeFile));

type = SlicingMode::kPlanar;

break;

}

m_slicing_mode = type;

// Reset part steps

for (QSharedPointer<Part> part : m_parts) { part->clearSteps(); }

// Reconnect the signal to the AST.

QObject::connect(this, &SessionManager::startSlice, m_ast.get(), &AbstractSlicingThread::doSlice);

connect(m_ast.get(), &AbstractSlicingThread::statusUpdate, this, &SessionManager::forwardDialogUpdate);

connect(m_ast.get(), &AbstractSlicingThread::statusMessage, this, &SessionManager::forwardStatusUpdate);

connect(m_ast.get(), &AbstractSlicingThread::sliceComplete, this, &SessionManager::sliceComplete);

return true;

if (!hasSuffix(path, {"s2p"})) return;

addRecentFile(m_recent_project_files, path);

m_dirty_history = true;

if (mt != MeshType::kBuild || !hasSuffix(path, {"stl", "3mf", "obj", "amf", "step", "stp"})) return;

addRecentFile(m_recent_model_files, path);

m_dirty_history = true;

path = absoluteFilePath(path);

const bool removed_project = m_recent_project_files.removeAll(path) > 0;

const bool removed_model = m_recent_model_files.removeAll(path) > 0;

if (removed_project || removed_model) m_dirty_history = true;

if (m_recent_project_files.isEmpty() && m_recent_model_files.isEmpty()) return;

m_recent_project_files.clear();

m_recent_model_files.clear();

m_dirty_history = true;