PyObject *SelectionSingleton::sAddSelection(PyObject * /*self*/, PyObject *args, PyObject * /*kwd*/)
{
PyObject *object;
char* subname=0;
float x=0,y=0,z=0;
if (PyArg_ParseTuple(args, "O!|sfff", &(App::DocumentObjectPy::Type),&object,&subname,&x,&y,&z)) {
App::DocumentObjectPy* docObjPy = static_cast<App::DocumentObjectPy*>(object);
App::DocumentObject* docObj = docObjPy->getDocumentObjectPtr();
if (!docObj || !docObj->getNameInDocument()) {
PyErr_SetString(Base::BaseExceptionFreeCADError, "Cannot check invalid object");
return NULL;
}
Selection().addSelection(docObj->getDocument()->getName(),
docObj->getNameInDocument(),
subname,x,y,z);
Py_Return;
}
PyErr_Clear();
PyObject *sequence;
if (PyArg_ParseTuple(args, "O!O", &(App::DocumentObjectPy::Type),&object,&sequence)) {
App::DocumentObjectPy* docObjPy = static_cast<App::DocumentObjectPy*>(object);
App::DocumentObject* docObj = docObjPy->getDocumentObjectPtr();
if (!docObj || !docObj->getNameInDocument()) {
PyErr_SetString(Base::BaseExceptionFreeCADError, "Cannot check invalid object");
return NULL;
}
try {
if (PyTuple_Check(sequence) || PyList_Check(sequence)) {
Py::Sequence list(sequence);
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
std::string subname = static_cast<std::string>(Py::String(*it));
Selection().addSelection(docObj->getDocument()->getName(),
docObj->getNameInDocument(),
subname.c_str());
}
Py_Return;
}
}
catch (const Py::Exception&) {
// do nothing here
}
}
PyErr_SetString(PyExc_ValueError, "type must be 'DocumentObject[,subname[,x,y,z]]' or 'DocumentObject, list or tuple of subnames'");
return 0;
}
PyObject* SketchObjectPy::addExternal(PyObject *args)
{
char *ObjectName;
char *SubName;
if (!PyArg_ParseTuple(args, "ss:Give an object and subelement name", &ObjectName,&SubName))
return 0;
// get the target object for the external link
Sketcher::SketchObject* skObj = this->getSketchObjectPtr();
App::DocumentObject * Obj = skObj->getDocument()->getObject(ObjectName);
if (!Obj) {
std::stringstream str;
str << ObjectName << " does not exist in the document";
PyErr_SetString(PyExc_ValueError, str.str().c_str());
return 0;
}
// check if this type of external geometry is allowed
if (!skObj->isExternalAllowed(Obj->getDocument(), Obj)) {
std::stringstream str;
str << ObjectName << " is not allowed as external geometry of this sketch";
PyErr_SetString(PyExc_ValueError, str.str().c_str());
return 0;
}
// add the external
if (skObj->addExternal(Obj,SubName) < 0) {
std::stringstream str;
str << "Not able to add external shape element";
PyErr_SetString(PyExc_ValueError, str.str().c_str());
return 0;
}
Py_Return;
}
const string PropertyLinkSubList::getPyReprString()
{
assert(this->_lValueList.size() == this->_lSubList.size());
if (this->_lValueList.size() == 0)
return std::string("None");
std::stringstream strm;
strm << "[";
for (std::size_t i = 0; i < this->_lSubList.size(); i++) {
if (i>0)
strm << ",(";
else
strm << "(";
App::DocumentObject* obj = this->_lValueList[i];
if (obj) {
strm << "App.getDocument('" << obj->getDocument()->getName() << "')." << obj->getNameInDocument();
} else {
strm << "None";
}
strm << ",";
strm << "'" << this->_lSubList[i] << "'";
strm << ")";
}
strm << "]";
return strm.str();
}
void Gui::ActiveObjectList::setObject(App::DocumentObject* obj, const char* name, const Gui::HighlightMode& mode)
{
ParameterGrp::handle hGrp = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/TreeView");
bool autoExpand = hGrp->GetBool("TreeActiveAutoExpand", true);
if (hasObject(name)) {
App::DocumentObject* act = getObject<App::DocumentObject*>(name);
Gui::Document* doc = Application::Instance->getDocument(act->getDocument());
Gui::ViewProviderDocumentObject* viewProvider = static_cast
<Gui::ViewProviderDocumentObject*>(doc->getViewProvider(act));
doc->signalHighlightObject(*viewProvider, mode, false);
if (autoExpand)
doc->signalExpandObject(*viewProvider, Gui::Collapse);
}
if (obj) {
Gui::Document* doc = Application::Instance->getDocument(obj->getDocument());
Gui::ViewProviderDocumentObject* viewProvider = static_cast
<Gui::ViewProviderDocumentObject*>(doc->getViewProvider(obj));
doc->signalHighlightObject(*viewProvider, mode, true);
if (autoExpand)
doc->signalExpandObject(*viewProvider, Gui::Expand);
_ObjectMap[name] = obj;
}
else {
if (hasObject(name))
_ObjectMap.erase(name);
}
}
void ViewProviderDocumentObject::onAboutToRemoveProperty(const char* prop)
{
// transactions of view providers are also managed in App::Document.
App::DocumentObject* docobject = getObject();
App::Document* document = docobject ? docobject->getDocument() : nullptr;
if (document)
document->removePropertyOfObject(this, prop);
}
void OriginGroup::unsetupObject () {
App::DocumentObject *origin = Origin.getValue ();
if (origin && !origin->isDeleting ()) {
origin->getDocument ()->remObject (origin->getNameInDocument());
}
GeoFeatureGroup::unsetupObject ();
}
void TaskFeatureParameters::recomputeFeature()
{
if (!blockUpdate) {
App::DocumentObject* obj = vp->getObject ();
assert (obj);
obj->getDocument()->recomputeFeature ( obj );
}
}
void Body::unsetupObject () {
App::DocumentObject *origin = Origin.getValue ();
if (origin && !origin->isDeleting ()) {
origin->getDocument ()->remObject (origin->getNameInDocument());
}
Part::BodyBase::unsetupObject ();
}
void SelectionSingleton::slotRenamedObject(const App::DocumentObject& Obj)
{
// compare internals with the document and change them if needed
App::Document* pDoc = Obj.getDocument();
for (std::list<_SelObj>::iterator it = _SelList.begin(); it != _SelList.end(); ++it) {
if (it->pDoc == pDoc) {
it->DocName = pDoc->getName();
}
}
}
void ViewProviderDocumentObject::onBeforeChange(const App::Property* prop)
{
if (isAttachedToDocument()) {
App::DocumentObject* obj = getObject();
App::Document* doc = obj ? obj->getDocument() : 0;
if (doc) {
onBeforeChangeProperty(doc, prop);
}
}
}
Gui::Document* AlignmentGroup::getDocument() const
{
if (this->_views.empty())
return 0;
App::DocumentObject* pView = this->_views[0]->getObject();
if (pView) {
App::Document* rDoc = pView->getDocument();
Gui::Document* pDoc = Gui::Application::Instance->getDocument(rDoc);
return pDoc;
}
return 0;
}
/**
* Extracts the associated view providers of the objects of the associated object group group.
*/
void ViewProviderDocumentObjectGroup::getViewProviders(std::vector<ViewProviderDocumentObject*>& vp) const
{
App::DocumentObject* doc = getObject();
if (doc->getTypeId().isDerivedFrom(App::DocumentObjectGroup::getClassTypeId())) {
Gui::Document* gd = Application::Instance->getDocument(doc->getDocument());
App::DocumentObjectGroup* grp = (App::DocumentObjectGroup*)doc;
std::vector<App::DocumentObject*> obj = grp->getObjects();
for (std::vector<App::DocumentObject*>::iterator it = obj.begin(); it != obj.end(); ++it) {
ViewProvider* v = gd->getViewProvider(*it);
if (v && v->getTypeId().isDerivedFrom(ViewProviderDocumentObject::getClassTypeId()))
vp.push_back((ViewProviderDocumentObject*)v);
}
}
}
void ViewProviderGroupExtension::extensionDropObject(App::DocumentObject* obj) {
App::DocumentObject* grp = static_cast<App::DocumentObject*>(getExtendedViewProvider()->getObject());
App::Document* doc = grp->getDocument();
// build Python command for execution
QString cmd;
cmd = QString::fromLatin1("App.getDocument(\"%1\").getObject(\"%2\").addObject("
"App.getDocument(\"%1\").getObject(\"%3\"))")
.arg(QString::fromLatin1(doc->getName()))
.arg(QString::fromLatin1(grp->getNameInDocument()))
.arg(QString::fromLatin1(obj->getNameInDocument()));
Gui::Command::doCommand(Gui::Command::App, cmd.toUtf8());
}
bool TaskCSysDragger::accept()
{
lastTranslationIncrement = dragger->translationIncrement.getValue();
lastRotationIncrement = dragger->rotationIncrement.getValue();
App::DocumentObject* dObject = vpObject.getObject();
if (dObject) {
Gui::Document* document = Gui::Application::Instance->getDocument(dObject->getDocument());
assert(document);
document->commitCommand();
document->resetEdit();
document->getDocument()->recompute();
}
return Gui::TaskView::TaskDialog::accept();
}
QIcon ViewProviderInspection::getIcon() const
{
// Get the icon of the view provider to the associated feature
QIcon px = inherited::getIcon();
App::Property* pActual = pcObject->getPropertyByName("Actual");
if (pActual && pActual->getTypeId().isDerivedFrom( App::PropertyLink::getClassTypeId())) {
App::DocumentObject* docobj = ((App::PropertyLink*)pActual)->getValue();
if (docobj) {
Gui::Document* doc = Gui::Application::Instance->getDocument(docobj->getDocument());
Gui::ViewProvider* view = doc->getViewProvider(docobj);
px = view->getIcon();
}
}
return px;
}
static PyObject * exporter(PyObject *self, PyObject *args)
{
PyObject* object;
char* Name;
if (!PyArg_ParseTuple(args, "Oet",&object,"utf-8",&Name))
return NULL;
std::string EncodedName = std::string(Name);
PyMem_Free(Name);
PY_TRY {
Py::Sequence list(object);
if (list.size() == 0) {
Py_Return;
} else if (list.size() > 1)
Py_Error(Base::BaseExceptionFreeCADError, "Unable to export more than one object to a GCode file");
PyObject* item = list[0].ptr();
if (PyObject_TypeCheck(item, &(App::DocumentObjectPy::Type))) {
App::DocumentObject* obj = static_cast<App::DocumentObjectPy*>(item)->getDocumentObjectPtr();
std::string path = App::GetApplication().getHomePath();
path += "Mod/Path/PathScripts/";
QDir dir(QString::fromUtf8(path.c_str()), QString::fromAscii("post_*.py"));
QFileInfoList list = dir.entryInfoList();
std::vector<std::string> scripts;
for (int i = 0; i < list.size(); ++i) {
QFileInfo fileInfo = list.at(i);
scripts.push_back(fileInfo.baseName().toStdString());
}
std::string selected;
PathGui::DlgProcessorChooser Dlg(scripts);
if (Dlg.exec() != QDialog::Accepted) {
Py_Return;
}
selected = Dlg.getSelected();
std::ostringstream cmd;
App::Document* doc = obj->getDocument();
cmd << "Path.write(FreeCAD.getDocument(\"" << doc->getName() << "\").getObject(\"" << obj->getNameInDocument() << "\"),\"" << EncodedName << "\"";
if (!selected.empty())
cmd << ",\"" << selected << "\"";
cmd << ")";
Gui::Command::runCommand(Gui::Command::Gui,"import Path");
Gui::Command::runCommand(Gui::Command::Gui,cmd.str().c_str());
}
} PY_CATCH;
Py_Return;
}
Private(ViewProviderPartExt* vp) : ui(new Ui_TaskFaceColors()), view(0), vp(vp)
{
obj = vp->getObject();
doc = Gui::Application::Instance->getDocument(obj->getDocument());
// build up map edge->face
TopTools_IndexedMapOfShape mapOfShape;
TopExp_Explorer xp(static_cast<Part::Feature*>(obj)->Shape.getValue(), TopAbs_FACE);
while (xp.More()) {
mapOfShape.Add(xp.Current());
xp.Next();
}
current = vp->DiffuseColor.getValues();
if (current.empty())
current.push_back(vp->ShapeColor.getValue());
perface = current;
perface.resize(mapOfShape.Extent(), perface.front());
}
void ViewProviderDocumentObjectGroup::show(void)
{
// when reading the Visibility property from file then do not hide the
// objects of this group because they have stored their visibility status, too
if (!Visibility.testStatus(App::Property::User1) && !this->visible) {
App::DocumentObject * group = getObject();
if (group && group->getTypeId().isDerivedFrom(App::DocumentObjectGroup::getClassTypeId())) {
const std::vector<App::DocumentObject*> & links = static_cast<App::DocumentObjectGroup*>
(group)->Group.getValues();
Gui::Document* doc = Application::Instance->getDocument(group->getDocument());
for (std::vector<App::DocumentObject*>::const_iterator it = links.begin(); it != links.end(); ++it) {
ViewProvider* view = doc->getViewProvider(*it);
if (view) view->show();
}
}
}
ViewProviderDocumentObject::show();
this->visible = true;
}
PyObject *SelectionSingleton::sRemoveSelection(PyObject * /*self*/, PyObject *args, PyObject * /*kwd*/)
{
PyObject *object;
char* subname=0;
if (!PyArg_ParseTuple(args, "O!|s", &(App::DocumentObjectPy::Type),&object,&subname))
return NULL; // NULL triggers exception
App::DocumentObjectPy* docObjPy = static_cast<App::DocumentObjectPy*>(object);
App::DocumentObject* docObj = docObjPy->getDocumentObjectPtr();
if (!docObj || !docObj->getNameInDocument()) {
PyErr_SetString(PyExc_Exception, "Cannot check invalid object");
return NULL;
}
Selection().rmvSelection(docObj->getDocument()->getName(),
docObj->getNameInDocument(),
subname);
Py_Return;
}
PyObject *SelectionSingleton::sAddSelection(PyObject * /*self*/, PyObject *args, PyObject * /*kwd*/)
{
PyObject *object;
char* subname=0;
float x=0,y=0,z=0;
if (!PyArg_ParseTuple(args, "O!|sfff", &(App::DocumentObjectPy::Type),&object,&subname,&x,&y,&z))
return NULL; // NULL triggers exception
App::DocumentObjectPy* docObjPy = static_cast<App::DocumentObjectPy*>(object);
App::DocumentObject* docObj = docObjPy->getDocumentObjectPtr();
if (!docObj || !docObj->getNameInDocument()) {
PyErr_SetString(Base::BaseExceptionFreeCADError, "Cannot check invalid object");
return NULL;
}
Selection().addSelection(docObj->getDocument()->getName(),
docObj->getNameInDocument(),
subname,x,y,z);
Py_Return;
}
bool ThicknessWidget::reject()
{
if (d->loop.isRunning())
return false;
// save this and check if the object is still there after the
// transaction is aborted
std::string objname = d->thickness->getNameInDocument();
App::DocumentObject* source = d->thickness->Faces.getValue();
// roll back the done things
Gui::Command::abortCommand();
Gui::Command::doCommand(Gui::Command::Gui,"Gui.ActiveDocument.resetEdit()");
Gui::Command::updateActive();
// Thickness object was deleted
if (source && !source->getDocument()->getObject(objname.c_str())) {
Gui::Application::Instance->getViewProvider(source)->show();
}
return true;
}
PyObject* Application::sExport(PyObject * /*self*/, PyObject *args,PyObject * /*kwd*/)
{
PyObject* object;
char* Name;
if (!PyArg_ParseTuple(args, "Oet",&object,"utf-8",&Name))
return NULL;
std::string Utf8Name = std::string(Name);
PyMem_Free(Name);
PY_TRY {
App::Document* doc = 0;
Py::Sequence list(object);
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
PyObject* item = (*it).ptr();
if (PyObject_TypeCheck(item, &(App::DocumentObjectPy::Type))) {
App::DocumentObject* obj = static_cast<App::DocumentObjectPy*>(item)->getDocumentObjectPtr();
doc = obj->getDocument();
break;
}
}
QString fileName = QString::fromUtf8(Utf8Name.c_str());
QFileInfo fi;
fi.setFile(fileName);
QString ext = fi.suffix().toLower();
if (ext == QLatin1String("iv") || ext == QLatin1String("wrl") ||
ext == QLatin1String("vrml") || ext == QLatin1String("wrz")) {
// build up the graph
SoSeparator* sep = new SoSeparator();
sep->ref();
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
PyObject* item = (*it).ptr();
if (PyObject_TypeCheck(item, &(App::DocumentObjectPy::Type))) {
App::DocumentObject* obj = static_cast<App::DocumentObjectPy*>(item)->getDocumentObjectPtr();
Gui::ViewProvider* vp = Gui::Application::Instance->getViewProvider(obj);
if (vp) {
sep->addChild(vp->getRoot());
}
}
}
SoGetPrimitiveCountAction action;
action.setCanApproximate(true);
action.apply(sep);
bool binary = false;
if (action.getTriangleCount() > 100000 ||
action.getPointCount() > 30000 ||
action.getLineCount() > 10000)
binary = true;
SoFCDB::writeToFile(sep, Utf8Name.c_str(), binary);
sep->unref();
}
else if (ext == QLatin1String("pdf")) {
// get the view that belongs to the found document
Gui::Document* gui_doc = Application::Instance->getDocument(doc);
if (gui_doc) {
Gui::MDIView* view = gui_doc->getActiveView();
if (view) {
View3DInventor* view3d = qobject_cast<View3DInventor*>(view);
if (view3d)
view3d->viewAll();
QPrinter printer(QPrinter::ScreenResolution);
printer.setOutputFormat(QPrinter::PdfFormat);
printer.setOutputFileName(fileName);
view->print(&printer);
}
}
}
else {
Base::Console().Error("File type '%s' not supported\n", ext.toLatin1().constData());
}
} PY_CATCH;
Py_Return;
}
PyObject* Application::sExport(PyObject * /*self*/, PyObject *args,PyObject * /*kwd*/)
{
PyObject* object;
const char* filename;
if (!PyArg_ParseTuple(args, "Os",&object,&filename))
return NULL;
PY_TRY {
App::Document* doc = 0;
Py::List list(object);
for (Py::List::iterator it = list.begin(); it != list.end(); ++it) {
PyObject* item = (*it).ptr();
if (PyObject_TypeCheck(item, &(App::DocumentObjectPy::Type))) {
App::DocumentObject* obj = static_cast<App::DocumentObjectPy*>(item)->getDocumentObjectPtr();
doc = obj->getDocument();
break;
}
}
// get the view that belongs to the found document
if (doc) {
QString fileName = QString::fromUtf8(filename);
QFileInfo fi;
fi.setFile(fileName);
QString ext = fi.completeSuffix().toLower();
if (ext == QLatin1String("iv") || ext == QLatin1String("wrl") ||
ext == QLatin1String("vrml") || ext == QLatin1String("wrz") ||
ext == QLatin1String("svg") || ext == QLatin1String("idtf")) {
Gui::Document* gui_doc = Application::Instance->getDocument(doc);
std::list<MDIView*> view3d = gui_doc->getMDIViewsOfType(View3DInventor::getClassTypeId());
if (view3d.empty()) {
PyErr_SetString(PyExc_Exception, "Cannot export to SVG because document doesn't have a 3d view");
return 0;
}
else {
QString cmd = QString::fromLatin1(
"Gui.getDocument(\"%1\").mdiViewsOfType('Gui::View3DInventor')[0].dump(\"%2\")"
).arg(QLatin1String(doc->getName())).arg(fi.absoluteFilePath());
Base::Interpreter().runString(cmd.toUtf8());
}
}
else if (ext == QLatin1String("pdf")) {
Gui::Document* gui_doc = Application::Instance->getDocument(doc);
if (gui_doc) {
Gui::MDIView* view = gui_doc->getActiveView();
if (view) {
View3DInventor* view3d = qobject_cast<View3DInventor*>(view);
if (view3d)
view3d->viewAll();
QPrinter printer(QPrinter::ScreenResolution);
printer.setOutputFormat(QPrinter::PdfFormat);
printer.setOutputFileName(fileName);
view->print(&printer);
}
}
}
}
} PY_CATCH;
Py_Return;
}
void SelectionSingleton::slotDeletedObject(const App::DocumentObject& Obj)
{
// remove also from the selection, if selected
Selection().rmvSelection( Obj.getDocument()->getName(), Obj.getNameInDocument() );
}
Py::Object exporter(const Py::Tuple& args)
{
PyObject* object;
char* Name;
if (!PyArg_ParseTuple(args.ptr(), "Oet",&object,"utf-8",&Name))
throw Py::Exception();
std::string EncodedName = std::string(Name);
PyMem_Free(Name);
Gui::WaitCursor wc;
wc.restoreCursor();
try {
Py::Sequence objlist(object);
if (objlist.size() == 0)
throw Py::RuntimeError("No object to export");
std::string path = App::GetApplication().getHomePath();
path += "Mod/Path/PathScripts/";
QDir dir1(QString::fromUtf8(path.c_str()), QString::fromLatin1("*_post.py"));
std::string cMacroPath = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/Macro")
->GetASCII("MacroPath",App::Application::getUserMacroDir().c_str());
QDir dir2(QString::fromUtf8(cMacroPath.c_str()), QString::fromLatin1("*_post.py"));
QFileInfoList list = dir1.entryInfoList();
list << dir2.entryInfoList();
std::vector<std::string> scripts;
for (int i = 0; i < list.size(); ++i) {
QFileInfo fileInfo = list.at(i);
scripts.push_back(fileInfo.baseName().toStdString());
}
PathGui::DlgProcessorChooser Dlg(scripts, true);
if (Dlg.exec() != QDialog::Accepted) {
return Py::None();
}
std::string processor = Dlg.getProcessor();
std::string arguments = Dlg.getArguments();
std::ostringstream pre;
std::ostringstream cmd;
if (processor.empty()) {
if (objlist.size() > 1) {
throw Py::RuntimeError("Cannot export more than one object without using a post script");
}
PyObject* item = objlist[0].ptr();
if (PyObject_TypeCheck(item, &(App::DocumentObjectPy::Type))) {
App::DocumentObject* obj = static_cast<App::DocumentObjectPy*>(item)->getDocumentObjectPtr();
App::Document* doc = obj->getDocument();
Gui::Command::runCommand(Gui::Command::Gui,"import Path");
cmd << "Path.write(FreeCAD.getDocument(\"" << doc->getName() << "\").getObject(\"" << obj->getNameInDocument() << "\"),\"" << EncodedName << "\")";
Gui::Command::runCommand(Gui::Command::Gui,cmd.str().c_str());
} else {
return Py::None();
}
} else {
for (int i = 0; i < list.size(); ++i) {
QFileInfo fileInfo = list.at(i);
if (fileInfo.baseName().toStdString() == processor) {
if (fileInfo.absoluteFilePath().contains(QString::fromLatin1("PathScripts"))) {
pre << "from PathScripts import " << processor;
} else {
pre << "import " << processor;
}
Gui::Command::runCommand(Gui::Command::Gui,pre.str().c_str());
cmd << processor << ".export(__objs__,\"" << EncodedName << "\",\"" << arguments << "\")";
Gui::Command::runCommand(Gui::Command::Gui,cmd.str().c_str());
}
}
}
}
catch (const Base::Exception& e) {
throw Py::RuntimeError(e.what());
}
return Py::None();
}
void DlgExtrusion::writeParametersToFeature(App::DocumentObject &feature, App::DocumentObject* base) const
{
Gui::Command::doCommand(Gui::Command::Doc,"f = App.getDocument('%s').getObject('%s')", feature.getDocument()->getName(), feature.getNameInDocument());
if (base)
Gui::Command::doCommand(Gui::Command::Doc,"f.Base = App.getDocument('%s').getObject('%s')", base->getDocument()->getName(), base->getNameInDocument());
Part::Extrusion::eDirMode dirMode = this->getDirMode();
const char* modestr = Part::Extrusion::eDirModeStrings[dirMode];
Gui::Command::doCommand(Gui::Command::Doc,"f.DirMode = \"%s\"", modestr);
if (dirMode == Part::Extrusion::dmCustom){
Base::Vector3d dir = this->getDir();
Gui::Command::doCommand(Gui::Command::Doc, "f.Dir = App.Vector(%.15f, %.15f, %.15f)", dir.x, dir.y, dir.z);
}
App::PropertyLinkSub lnk;
this->getAxisLink(lnk);
std::stringstream linkstr;
if(lnk.getValue() == nullptr){
linkstr << "None";
} else {
linkstr << "(App.getDocument(\"" << lnk.getValue()->getDocument()->getName() <<"\")." << lnk.getValue()->getNameInDocument();
linkstr << ", [";
for (const std::string &str: lnk.getSubValues()){
linkstr << "\"" << str << "\"";
}
linkstr << "])";
}
Gui::Command::doCommand(Gui::Command::Doc,"f.DirLink = %s", linkstr.str().c_str());
Gui::Command::doCommand(Gui::Command::Doc,"f.LengthFwd = %.15f", ui->spinLenFwd->value().getValue());
Gui::Command::doCommand(Gui::Command::Doc,"f.LengthRev = %.15f", ui->spinLenRev->value().getValue());
Gui::Command::doCommand(Gui::Command::Doc,"f.Solid = %s", ui->chkSolid->isChecked() ? "True" : "False");
Gui::Command::doCommand(Gui::Command::Doc,"f.Reversed = %s", ui->chkReversed->isChecked() ? "True" : "False");
Gui::Command::doCommand(Gui::Command::Doc,"f.Symmetric = %s", ui->chkSymmetric->isChecked() ? "True" : "False");
Gui::Command::doCommand(Gui::Command::Doc,"f.TaperAngle = %.15f", ui->spinTaperAngle->value().getValue());
Gui::Command::doCommand(Gui::Command::Doc,"f.TaperAngleRev = %.15f", ui->spinTaperAngleRev->value().getValue());
}
static PyObject * exporter(PyObject *self, PyObject *args)
{
PyObject* object;
char* Name;
if (!PyArg_ParseTuple(args, "Oet",&object,"utf-8",&Name))
return NULL;
std::string EncodedName = std::string(Name);
PyMem_Free(Name);
Gui::WaitCursor wc;
wc.restoreCursor();
PY_TRY {
Py::Sequence objlist(object);
if (objlist.size() == 0)
Py_Error(Base::BaseExceptionFreeCADError, "No object to export");
std::string path = App::GetApplication().getHomePath();
path += "Mod/Path/PathScripts/";
QDir dir1(QString::fromUtf8(path.c_str()), QString::fromAscii("*_post.py"));
std::string cMacroPath = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/Macro")
->GetASCII("MacroPath",App::Application::getUserAppDataDir().c_str());
QDir dir2(QString::fromUtf8(cMacroPath.c_str()), QString::fromAscii("*_post.py"));
QFileInfoList list = dir1.entryInfoList();
list << dir2.entryInfoList();
std::vector<std::string> scripts;
for (int i = 0; i < list.size(); ++i) {
QFileInfo fileInfo = list.at(i);
scripts.push_back(fileInfo.baseName().toStdString());
}
std::string selected;
PathGui::DlgProcessorChooser Dlg(scripts);
if (Dlg.exec() != QDialog::Accepted) {
Py_Return;
}
selected = Dlg.getSelected();
std::ostringstream pre;
std::ostringstream cmd;
if (selected.empty()) {
if (objlist.size() > 1) {
Py_Error(Base::BaseExceptionFreeCADError, "Cannot export more than one object without using a post script");
}
PyObject* item = objlist[0].ptr();
if (PyObject_TypeCheck(item, &(App::DocumentObjectPy::Type))) {
App::DocumentObject* obj = static_cast<App::DocumentObjectPy*>(item)->getDocumentObjectPtr();
App::Document* doc = obj->getDocument();
Gui::Command::runCommand(Gui::Command::Gui,"import Path");
cmd << "Path.write(FreeCAD.getDocument(\"" << doc->getName() << "\").getObject(\"" << obj->getNameInDocument() << "\"),\"" << EncodedName << "\")";
Gui::Command::runCommand(Gui::Command::Gui,cmd.str().c_str());
} else {
Py_Return;
}
} else {
for (int i = 0; i < list.size(); ++i) {
QFileInfo fileInfo = list.at(i);
if (fileInfo.baseName().toStdString() == selected) {
if (fileInfo.absoluteFilePath().contains(QString::fromAscii("PathScripts"))) {
pre << "from PathScripts import " << selected;
} else {
pre << "import " << selected;
}
Gui::Command::runCommand(Gui::Command::Gui,pre.str().c_str());
cmd << selected << ".export(__objs__,\"" << EncodedName << "\")";
Gui::Command::runCommand(Gui::Command::Gui,cmd.str().c_str());
}
}
}
} PY_CATCH;
Py_Return;
}