kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Materials: External interface refinements (#21524)

Browse Source
This commit is contained in:
David Carter
2025-05-24 06:25:44 +00:00
committed by GitHub
parent 0ef4ee0367
commit 13b7991705
37 changed files with 1147 additions and 406 deletions
Download Patch File Download Diff File Expand all files Collapse all files

625
src/Mod/Material/App/ExternalManager.cpp
View File

@@ -36,8 +36,10 @@
#include "ExternalManager.h"
#include "MaterialLibrary.h"
#include "MaterialLibraryPy.h"
#include "MaterialManager.h"
#include "MaterialPy.h"
#include "ModelLibrary.h"
#include "ModelManager.h"
#include "ModelPy.h"
#include "MaterialFilterPy.h"
#include "MaterialFilterOptionsPy.h"
@@ -98,10 +100,10 @@ void ExternalManager::getConfiguration()
void ExternalManager::instantiate()
{
_instantiated = false;
Base::Console().Log("Loading external manager...\n");
Base::Console().log("Loading external manager...\n");
if (_moduleName.empty() || _className.empty()) {
Base::Console().Log("External module not defined\n");
Base::Console().log("External module not defined\n");
return;
}
@@ -110,7 +112,7 @@ void ExternalManager::instantiate()
Py::Module mod(PyImport_ImportModule(_moduleName.c_str()), true);
if (mod.isNull()) {
Base::Console().Log(" failed\n");
Base::Console().log(" failed\n");
return;
}
@@ -121,14 +123,14 @@ void ExternalManager::instantiate()
}
if (_instantiated) {
Base::Console().Log("done\n");
Base::Console().log("done\n");
}
else {
Base::Console().Log("failed\n");
Base::Console().log("failed\n");
}
}
catch (Py::Exception& e) {
Base::Console().Log("failed\n");
Base::Console().log("failed\n");
e.clear();
}
}
@@ -168,8 +170,7 @@ ExternalManager* ExternalManager::getManager()
bool ExternalManager::checkMaterialLibraryType(const Py::Object& entry)
{
return entry.hasAttr("name") && entry.hasAttr("icon") && entry.hasAttr("readOnly")
&& entry.hasAttr("timestamp");
return entry.hasAttr("name") && entry.hasAttr("icon") && entry.hasAttr("readOnly");
}
std::shared_ptr<Library>
@@ -180,57 +181,53 @@ ExternalManager::libraryFromObject(const Py::Object& entry)
}
Py::String pyName(entry.getAttr("name"));
Py::Bytes pyIcon(entry.getAttr("icon"));
Py::Bytes pyIcon;
if (entry.getAttr("icon") != Py::None()) {
pyIcon = Py::Bytes(entry.getAttr("icon"));
}
Py::Boolean pyReadOnly(entry.getAttr("readOnly"));
Py::String pyTimestamp(entry.getAttr("timestamp"));
QString libraryName;
if (!pyName.isNone()) {
libraryName = QString::fromStdString(pyName.as_string());
}
QString icon;
QByteArray icon;
if (!pyIcon.isNone()) {
icon = QString::fromStdString(pyIcon.as_string());
icon = QByteArray(pyIcon.as_std_string().data(), pyIcon.size());
}
bool readOnly = pyReadOnly.as_bool();
QString timestamp;
if (!pyTimestamp.isNone()) {
timestamp = QString::fromStdString(pyTimestamp.as_string());
}
auto library = std::make_shared<Library>(libraryName, icon, readOnly, timestamp);
auto library = std::make_shared<Library>(libraryName, icon, readOnly);
return library;
}
bool ExternalManager::checkMaterialObjectType(const Py::Object& entry)
bool ExternalManager::checkMaterialLibraryObjectType(const Py::Object& entry)
{
return entry.hasAttr("UUID") && entry.hasAttr("path") && entry.hasAttr("name");
}
std::tuple<QString, QString, QString>
ExternalManager::materialObjectTypeFromObject(const Py::Object& entry)
LibraryObject ExternalManager::materialLibraryObjectTypeFromObject(const Py::Object& entry)
{
QString uuid;
std::string uuid;
auto pyUUID = entry.getAttr("UUID");
if (!pyUUID.isNone()) {
uuid = QString::fromStdString(pyUUID.as_string());
uuid = pyUUID.as_string();
}
QString path;
std::string path;
auto pyPath = entry.getAttr("path");
if (!pyPath.isNone()) {
path = QString::fromStdString(pyPath.as_string());
path = pyPath.as_string();
}
QString name;
std::string name;
auto pyName = entry.getAttr("name");
if (!pyName.isNone()) {
name = QString::fromStdString(pyName.as_string());
name = pyName.as_string();
}
return std::tuple<QString, QString, QString>(uuid, path, name);
return LibraryObject(uuid, path, name);
}
std::shared_ptr<std::vector<std::shared_ptr<Library>>>
@@ -251,12 +248,13 @@ ExternalManager::libraries()
}
}
else {
Base::Console().Log("\tlibraries() not found\n");
Base::Console().log("\tlibraries() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
Base::Console().log("Library error %s", e1.what());
throw LibraryNotFound(e1.what());
}
@@ -280,7 +278,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Library>>> ExternalManager::modelLib
}
}
else {
Base::Console().Log("\tmodelLibraries() not found\n");
Base::Console().log("\tmodelLibraries() not found\n");
throw ConnectionError();
}
}
@@ -309,7 +307,7 @@ std::shared_ptr<std::vector<std::shared_ptr<Library>>> ExternalManager::material
}
}
else {
Base::Console().Log("\tmaterialLibraries() not found\n");
Base::Console().log("\tmaterialLibraries() not found\n");
throw ConnectionError();
}
}
@@ -332,24 +330,26 @@ std::shared_ptr<Library> ExternalManager::getLibrary(const QString& name)
Py::Callable libraries(_managerObject.getAttr("getLibrary"));
Py::Tuple args(1);
args.setItem(0, Py::String(name.toStdString()));
Py::Tuple result(libraries.apply(args));
Py::Object result(libraries.apply(args));
Py::Object libObject = result.getItem(0);
auto lib = libraryFromObject(Py::Tuple(libObject));
auto lib = libraryFromObject(result);
return std::make_shared<Library>(*lib);
}
else {
Base::Console().Log("\tgetLibrary() not found\n");
Base::Console().log("\tgetLibrary() not found\n");
throw ConnectionError();
}
}
catch (const InvalidLibrary&) {
throw LibraryNotFound();
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw CreationError(e1.what());
throw LibraryNotFound(e1.what());
}
}
void ExternalManager::createLibrary(const QString& libraryName, const QString& icon, bool readOnly)
void ExternalManager::createLibrary(const QString& libraryName, const QByteArray& icon, bool readOnly)
{
connect();
@@ -359,12 +359,12 @@ void ExternalManager::createLibrary(const QString& libraryName, const QString& i
Py::Callable libraries(_managerObject.getAttr("createLibrary"));
Py::Tuple args(3);
args.setItem(0, Py::String(libraryName.toStdString()));
args.setItem(1, Py::String(icon.toStdString()));
args.setItem(1, Py::Bytes(icon.data(), icon.size()));
args.setItem(2, Py::Boolean(readOnly));
libraries.apply(args); // No return expected
}
else {
Base::Console().Log("\tcreateLibrary() not found\n");
Base::Console().log("\tcreateLibrary() not found\n");
throw ConnectionError();
}
}
@@ -388,7 +388,7 @@ void ExternalManager::renameLibrary(const QString& libraryName, const QString& n
libraries.apply(args); // No return expected
}
else {
Base::Console().Log("\trenameLibrary() not found\n");
Base::Console().log("\trenameLibrary() not found\n");
throw ConnectionError();
}
}
@@ -398,7 +398,7 @@ void ExternalManager::renameLibrary(const QString& libraryName, const QString& n
}
}
void ExternalManager::changeIcon(const QString& libraryName, const QString& icon)
void ExternalManager::changeIcon(const QString& libraryName, const QByteArray& icon)
{
connect();
@@ -408,11 +408,11 @@ void ExternalManager::changeIcon(const QString& libraryName, const QString& icon
Py::Callable libraries(_managerObject.getAttr("changeIcon"));
Py::Tuple args(2);
args.setItem(0, Py::String(libraryName.toStdString()));
args.setItem(1, Py::String(icon.toStdString()));
args.setItem(1, Py::Bytes(icon.data(), icon.size()));
libraries.apply(args); // No return expected
}
else {
Base::Console().Log("\tchangeIcon() not found\n");
Base::Console().log("\tchangeIcon() not found\n");
throw ConnectionError();
}
}
@@ -435,7 +435,7 @@ void ExternalManager::removeLibrary(const QString& libraryName)
libraries.apply(args); // No return expected
}
else {
Base::Console().Log("\tremoveLibrary() not found\n");
Base::Console().log("\tremoveLibrary() not found\n");
throw ConnectionError();
}
}
@@ -445,10 +445,10 @@ void ExternalManager::removeLibrary(const QString& libraryName)
}
}
std::shared_ptr<std::vector<std::tuple<QString, QString, QString>>>
std::shared_ptr<std::vector<LibraryObject>>
ExternalManager::libraryModels(const QString& libraryName)
{
auto modelList = std::make_shared<std::vector<std::tuple<QString, QString, QString>>>();
auto modelList = std::make_shared<std::vector<LibraryObject>>();
connect();
@@ -461,15 +461,15 @@ ExternalManager::libraryModels(const QString& libraryName)
Py::List list(libraries.apply(args));
for (auto library : list) {
auto entry = Py::Object(library);
if (!checkMaterialObjectType(entry)) {
if (!checkMaterialLibraryObjectType(entry)) {
throw InvalidModel();
}
modelList->push_back(materialObjectTypeFromObject(entry));
modelList->push_back(materialLibraryObjectTypeFromObject(entry));
}
}
else {
Base::Console().Log("\tlibraryModels() not found\n");
Base::Console().log("\tlibraryModels() not found\n");
throw ConnectionError();
}
}
@@ -481,10 +481,10 @@ ExternalManager::libraryModels(const QString& libraryName)
return modelList;
}
std::shared_ptr<std::vector<std::tuple<QString, QString, QString>>>
std::shared_ptr<std::vector<LibraryObject>>
ExternalManager::libraryMaterials(const QString& libraryName)
{
auto materialList = std::make_shared<std::vector<std::tuple<QString, QString, QString>>>();
auto materialList = std::make_shared<std::vector<LibraryObject>>();
connect();
@@ -497,15 +497,15 @@ ExternalManager::libraryMaterials(const QString& libraryName)
Py::List list(libraries.apply(args));
for (auto library : list) {
auto entry = Py::Object(library);
if (!checkMaterialObjectType(entry)) {
if (!checkMaterialLibraryObjectType(entry)) {
throw InvalidMaterial();
}
materialList->push_back(materialObjectTypeFromObject(entry));
materialList->push_back(materialLibraryObjectTypeFromObject(entry));
}
}
else {
Base::Console().Log("\tlibraryMaterials() not found\n");
Base::Console().log("\tlibraryMaterials() not found\n");
throw ConnectionError();
}
}
@@ -517,12 +517,12 @@ ExternalManager::libraryMaterials(const QString& libraryName)
return materialList;
}
std::shared_ptr<std::vector<std::tuple<QString, QString, QString>>>
std::shared_ptr<std::vector<LibraryObject>>
ExternalManager::libraryMaterials(const QString& libraryName,
const std::shared_ptr<MaterialFilter>& filter,
const MaterialFilterOptions& options)
{
auto materialList = std::make_shared<std::vector<std::tuple<QString, QString, QString>>>();
auto materialList = std::make_shared<std::vector<LibraryObject>>();
connect();
@@ -545,15 +545,15 @@ ExternalManager::libraryMaterials(const QString& libraryName,
Py::List list(libraries.apply(args));
for (auto library : list) {
auto entry = Py::Object(library);
if (!checkMaterialObjectType(entry)) {
if (!checkMaterialLibraryObjectType(entry)) {
throw InvalidMaterial();
}
materialList->push_back(materialObjectTypeFromObject(entry));
materialList->push_back(materialLibraryObjectTypeFromObject(entry));
}
}
else {
Base::Console().Log("\tlibraryMaterials() not found\n");
Base::Console().log("\tlibraryMaterials() not found\n");
throw ConnectionError();
}
}
@@ -565,12 +565,162 @@ ExternalManager::libraryMaterials(const QString& libraryName,
return materialList;
}
std::shared_ptr<std::vector<QString>> ExternalManager::libraryFolders(const QString& libraryName)
{
auto folderList = std::make_shared<std::vector<QString>>();
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("libraryFolders")) {
Py::Callable folders(_managerObject.getAttr("libraryFolders"));
Py::Tuple args(1);
args.setItem(0, Py::String(libraryName.toStdString()));
Py::List list(folders.apply(args));
for (auto folder : list) {
auto entry = Py::Object(folder);
Py::String pyName(entry.getAttr("name"));
QString folderName;
if (!pyName.isNone()) {
folderName = QString::fromStdString(pyName.as_string());
}
folderList->push_back(folderName);
}
}
else {
Base::Console().log("\tlibraryFolders() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw LibraryNotFound(e1.what());
}
return folderList;
}
//=====
//
// Folder management
//
//=====
void ExternalManager::createFolder(const QString& libraryName, const QString& path)
{
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("createFolder")) {
Py::Callable libraries(_managerObject.getAttr("createFolder"));
Py::Tuple args(2);
args.setItem(0, Py::String(libraryName.toStdString()));
args.setItem(1, Py::String(path.toStdString()));
Py::Object result(libraries.apply(args));
}
else {
Base::Console().log("\tcreateFolder() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw CreationError(e1.what());
}
}
void ExternalManager::renameFolder(const QString& libraryName,
const QString& oldPath,
const QString& newPath)
{
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("renameFolder")) {
Py::Callable libraries(_managerObject.getAttr("renameFolder"));
Py::Tuple args(3);
args.setItem(0, Py::String(libraryName.toStdString()));
args.setItem(1, Py::String(oldPath.toStdString()));
args.setItem(2, Py::String(newPath.toStdString()));
Py::Object result(libraries.apply(args));
}
else {
Base::Console().log("\trenameFolder() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw RenameError(e1.what());
}
}
void ExternalManager::deleteRecursive(const QString& libraryName, const QString& path)
{
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("deleteRecursive")) {
Py::Callable libraries(_managerObject.getAttr("deleteRecursive"));
Py::Tuple args(2);
args.setItem(0, Py::String(libraryName.toStdString()));
args.setItem(1, Py::String(path.toStdString()));
Py::Object result(libraries.apply(args));
}
else {
Base::Console().log("\tdeleteRecursive() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw DeleteError(e1.what());
}
}
//=====
//
// Model management
//
//=====
bool ExternalManager::checkModelObjectType(const Py::Object& entry)
{
return entry.hasAttr("libraryName") && entry.hasAttr("model");
}
std::shared_ptr<Model> ExternalManager::modelFromObject(const Py::Object& entry,
const QString& uuid)
{
if (!checkModelObjectType(entry)) {
throw InvalidModel();
}
Py::String pyName(entry.getAttr("libraryName"));
Py::Object modelObject(entry.getAttr("model"));
QString libraryName;
if (!pyName.isNone()) {
libraryName = QString::fromStdString(pyName.as_string());
}
// Using this call will use caching, whereas using our class function will not
auto library = ModelManager::getManager().getLibrary(libraryName);
Model* model = static_cast<ModelPy*>(*modelObject)->getModelPtr();
model->setUUID(uuid);
model->setLibrary(library);
auto shared = std::make_shared<Model>(*model);
return shared;
}
std::shared_ptr<Model> ExternalManager::getModel(const QString& uuid)
{
connect();
@@ -581,36 +731,14 @@ std::shared_ptr<Model> ExternalManager::getModel(const QString& uuid)
Py::Callable libraries(_managerObject.getAttr("getModel"));
Py::Tuple args(1);
args.setItem(0, Py::String(uuid.toStdString()));
Py::Tuple result(libraries.apply(args)); // ignore return for now
Py::Object result(libraries.apply(args)); // ignore return for now
Py::Object uuidObject = result.getItem(0);
Py::Tuple libraryObject(result.getItem(1));
Py::Object modelObject = result.getItem(2);
Py::Object pyName = libraryObject.getItem(0);
Py::Object pyIcon = libraryObject.getItem(1);
Py::Object readOnly = libraryObject.getItem(2);
QString name;
if (!pyName.isNone()) {
name = QString::fromStdString(pyName.as_string());
}
QString icon;
if (!pyIcon.isNone()) {
icon = QString::fromStdString(pyIcon.as_string());
}
auto library =
std::make_shared<ModelLibrary>(name, QString(), icon, readOnly.as_bool());
Model* model = static_cast<ModelPy*>(*modelObject)->getModelPtr();
model->setUUID(uuid);
model->setLibrary(library);
auto shared = std::make_shared<Model>(*model);
auto shared = modelFromObject(result, uuid);
return shared;
}
else {
Base::Console().Log("\tgetModel() not found\n");
Base::Console().log("\tgetModel() not found\n");
throw ConnectionError();
}
}
@@ -637,7 +765,7 @@ void ExternalManager::addModel(const QString& libraryName,
libraries.apply(args); // No return expected
}
else {
Base::Console().Log("\taddModel() not found\n");
Base::Console().log("\taddModel() not found\n");
throw ConnectionError();
}
}
@@ -664,7 +792,7 @@ void ExternalManager::migrateModel(const QString& libraryName,
libraries.apply(args); // No return expected
}
else {
Base::Console().Log("\tmigrateModel() not found\n");
Base::Console().log("\tmigrateModel() not found\n");
throw ConnectionError();
}
}
@@ -674,12 +802,174 @@ void ExternalManager::migrateModel(const QString& libraryName,
}
}
void ExternalManager::updateModel(const QString& libraryName,
const QString& path,
const std::shared_ptr<Model>& model)
{
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("updateModel")) {
Py::Callable libraries(_managerObject.getAttr("updateModel"));
Py::Tuple args(3);
args.setItem(0, Py::String(libraryName.toStdString()));
args.setItem(1, Py::String(path.toStdString()));
args.setItem(2, Py::Object(new ModelPy(new Model(*model)), true));
libraries.apply(args); // No return expected
}
else {
Base::Console().log("\tupdateModel() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw UpdateError(e1.what());
}
}
void ExternalManager::setModelPath(const QString& libraryName,
const QString& path,
const QString& uuid)
{
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("setModelPath")) {
Py::Callable libraries(_managerObject.getAttr("setModelPath"));
Py::Tuple args(3);
args.setItem(0, Py::String(libraryName.toStdString()));
args.setItem(1, Py::String(path.toStdString()));
args.setItem(2, Py::String(uuid.toStdString()));
libraries.apply(args); // No return expected
}
else {
Base::Console().log("\tsetModelPath() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw UpdateError(e1.what());
}
}
void ExternalManager::renameModel(const QString& libraryName,
const QString& name,
const QString& uuid)
{
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("renameModel")) {
Py::Callable libraries(_managerObject.getAttr("renameModel"));
Py::Tuple args(3);
args.setItem(0, Py::String(libraryName.toStdString()));
args.setItem(1, Py::String(name.toStdString()));
args.setItem(2, Py::String(uuid.toStdString()));
libraries.apply(args); // No return expected
}
else {
Base::Console().log("\trenameModel() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw RenameError(e1.what());
}
}
void ExternalManager::moveModel(const QString& libraryName,
const QString& path,
const QString& uuid)
{
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("moveModel")) {
Py::Callable libraries(_managerObject.getAttr("moveModel"));
Py::Tuple args(3);
args.setItem(0, Py::String(libraryName.toStdString()));
args.setItem(1, Py::String(path.toStdString()));
args.setItem(2, Py::String(uuid.toStdString()));
libraries.apply(args); // No return expected
}
else {
Base::Console().log("\tmoveModel() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw MoveError(e1.what());
}
}
void ExternalManager::removeModel(const QString& uuid)
{
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("removeModel")) {
Py::Callable libraries(_managerObject.getAttr("removeModel"));
Py::Tuple args(1);
args.setItem(0, Py::String(uuid.toStdString()));
libraries.apply(args); // No return expected
}
else {
Base::Console().log("\tremoveModel() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw DeleteError(e1.what());
}
}
//=====
//
// Material management
//
//=====
bool ExternalManager::checkMaterialObjectType(const Py::Object& entry)
{
return entry.hasAttr("libraryName") && entry.hasAttr("material");
}
std::shared_ptr<Material> ExternalManager::materialFromObject(const Py::Object& entry,
const QString& uuid)
{
if (!checkMaterialObjectType(entry)) {
throw InvalidMaterial();
}
Py::String pyName(entry.getAttr("libraryName"));
Py::Object materialObject(entry.getAttr("material"));
QString libraryName;
if (!pyName.isNone()) {
libraryName = QString::fromStdString(pyName.as_string());
}
// Using this call will use caching, whereas using our class function will not
auto library = MaterialManager::getManager().getLibrary(libraryName);
Material* material = static_cast<MaterialPy*>(*materialObject)->getMaterialPtr();
material->setUUID(uuid);
material->setLibrary(library);
auto shared = std::make_shared<Material>(*material);
return shared;
}
std::shared_ptr<Material> ExternalManager::getMaterial(const QString& uuid)
{
connect();
@@ -690,36 +980,14 @@ std::shared_ptr<Material> ExternalManager::getMaterial(const QString& uuid)
Py::Callable libraries(_managerObject.getAttr("getMaterial"));
Py::Tuple args(1);
args.setItem(0, Py::String(uuid.toStdString()));
Py::Tuple result(libraries.apply(args));
Py::Object result(libraries.apply(args));
Py::Object uuidObject = result.getItem(0);
Py::Tuple libraryObject(result.getItem(1));
Py::Object materialObject = result.getItem(2);
Py::Object pyName = libraryObject.getItem(0);
Py::Object pyIcon = libraryObject.getItem(1);
Py::Object readOnly = libraryObject.getItem(2);
QString name;
if (!pyName.isNone()) {
name = QString::fromStdString(pyName.as_string());
}
QString icon;
if (!pyIcon.isNone()) {
icon = QString::fromStdString(pyIcon.as_string());
}
auto library =
std::make_shared<MaterialLibrary>(name, QString(), icon, readOnly.as_bool());
Material* material = static_cast<MaterialPy*>(*materialObject)->getMaterialPtr();
material->setUUID(uuid);
material->setLibrary(library);
auto shared = std::make_shared<Material>(*material);
auto shared = materialFromObject(result, uuid);
return shared;
}
else {
Base::Console().Log("\tgetMaterial() not found\n");
Base::Console().log("\tgetMaterial() not found\n");
throw ConnectionError();
}
}
@@ -746,7 +1014,7 @@ void ExternalManager::addMaterial(const QString& libraryName,
libraries.apply(args); // No return expected
}
else {
Base::Console().Log("\taddMaterial() not found\n");
Base::Console().log("\taddMaterial() not found\n");
throw ConnectionError();
}
}
@@ -774,7 +1042,7 @@ void ExternalManager::migrateMaterial(const QString& libraryName,
libraries.apply(args); // No return expected
}
else {
Base::Console().Log("\tmigrateMaterial() not found\n");
Base::Console().log("\tmigrateMaterial() not found\n");
throw ConnectionError();
}
}
@@ -783,3 +1051,134 @@ void ExternalManager::migrateMaterial(const QString& libraryName,
throw CreationError(e1.what());
}
}
void ExternalManager::updateMaterial(const QString& libraryName,
const QString& path,
const std::shared_ptr<Material>& material)
{
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("updateMaterial")) {
Py::Callable libraries(_managerObject.getAttr("updateMaterial"));
Py::Tuple args(3);
args.setItem(0, Py::String(libraryName.toStdString()));
args.setItem(1, Py::String(path.toStdString()));
args.setItem(2, Py::Object(new MaterialPy(new Material(*material)), true));
libraries.apply(args); // No return expected
}
else {
Base::Console().log("\tupdateMaterial() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw UpdateError(e1.what());
}
}
void ExternalManager::setMaterialPath(const QString& libraryName,
const QString& path,
const QString& uuid)
{
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("setMaterialPath")) {
Py::Callable libraries(_managerObject.getAttr("setMaterialPath"));
Py::Tuple args(3);
args.setItem(0, Py::String(libraryName.toStdString()));
args.setItem(1, Py::String(path.toStdString()));
args.setItem(2, Py::String(uuid.toStdString()));
libraries.apply(args); // No return expected
}
else {
Base::Console().log("\tsetMaterialPath() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw UpdateError(e1.what());
}
}
void ExternalManager::renameMaterial(const QString& libraryName,
const QString& name,
const QString& uuid)
{
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("renameMaterial")) {
Py::Callable libraries(_managerObject.getAttr("renameMaterial"));
Py::Tuple args(3);
args.setItem(0, Py::String(libraryName.toStdString()));
args.setItem(1, Py::String(name.toStdString()));
args.setItem(2, Py::String(uuid.toStdString()));
libraries.apply(args); // No return expected
}
else {
Base::Console().log("\trenameMaterial() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw RenameError(e1.what());
}
}
void ExternalManager::moveMaterial(const QString& libraryName,
const QString& path,
const QString& uuid)
{
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("moveMaterial")) {
Py::Callable libraries(_managerObject.getAttr("moveMaterial"));
Py::Tuple args(3);
args.setItem(0, Py::String(libraryName.toStdString()));
args.setItem(1, Py::String(path.toStdString()));
args.setItem(2, Py::String(uuid.toStdString()));
libraries.apply(args); // No return expected
}
else {
Base::Console().log("\tmoveMaterial() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw MoveError(e1.what());
}
}
void ExternalManager::removeMaterial(const QString& uuid)
{
connect();
Base::PyGILStateLocker lock;
try {
if (_managerObject.hasAttr("removeMaterial")) {
Py::Callable libraries(_managerObject.getAttr("removeMaterial"));
Py::Tuple args(1);
args.setItem(0, Py::String(uuid.toStdString()));
libraries.apply(args); // No return expected
}
else {
Base::Console().log("\tremoveMaterial() not found\n");
throw ConnectionError();
}
}
catch (Py::Exception& e) {
Base::PyException e1; // extract the Python error text
throw DeleteError(e1.what());
}
}