void ViewProviderPythonFeatureObserver::slotAppendObject(const Gui::ViewProvider& obj) { if (!obj.isDerivedFrom(Gui::ViewProviderDocumentObject::getClassTypeId())) return; const Gui::ViewProviderDocumentObject& vp = static_cast<const Gui::ViewProviderDocumentObject&>(obj); const App::DocumentObject* docobj = vp.getObject(); App::Document* doc = docobj->getDocument(); std::map<const App::Document*, ObjectProxy>::iterator it = proxyMap.find(doc); if (it != proxyMap.end()) { ObjectProxy::iterator jt = it->second.find(docobj); if (jt != it->second.end()) { Base::PyGILStateLocker lock; try { App::Property* prop = vp.getPropertyByName("Proxy"); if (prop && prop->isDerivedFrom(App::PropertyPythonObject::getClassTypeId())) { // make this delayed so that the corresponding item in the tree view is accessible QApplication::postEvent(this, new PropertyEvent(&vp, jt->second)); // needed in customEvent() viewMap.insert(&vp); it->second.erase(jt); } } catch (Py::Exception& e) { e.clear(); } } // all cached objects of the documents are already destroyed else { it->second.clear(); } } }
const char* ViewProviderPythonFeatureImp::getDefaultDisplayMode() const { // Run the getDefaultDisplayMode method of the proxy object. Base::PyGILStateLocker lock; static std::string mode; try { App::Property* proxy = object->getPropertyByName("Proxy"); if (proxy && proxy->getTypeId() == App::PropertyPythonObject::getClassTypeId()) { Py::Object vp = static_cast<App::PropertyPythonObject*>(proxy)->getValue(); if (vp.hasAttr(std::string("getDefaultDisplayMode"))) { Py::Callable method(vp.getAttr(std::string("getDefaultDisplayMode"))); Py::Tuple args(0); Py::String str(method.apply(args)); if (str.isUnicode()) str = str.encode("ascii"); // json converts strings into unicode mode = str.as_std_string(); return mode.c_str(); } } } catch (Py::Exception&) { Base::PyException e; // extract the Python error text const char* name = object->getObject()->Label.getValue(); Base::Console().Error("ViewProviderPythonFeature::getDefaultDisplayMode (%s): %s\n", name, e.what()); } return 0; }
std::string ViewProviderPythonFeatureImp::setDisplayMode(const char* ModeName) { // Run the setDisplayMode method of the proxy object. Base::PyGILStateLocker lock; try { App::Property* proxy = object->getPropertyByName("Proxy"); if (proxy && proxy->getTypeId() == App::PropertyPythonObject::getClassTypeId()) { Py::Object vp = static_cast<App::PropertyPythonObject*>(proxy)->getValue(); if (vp.hasAttr(std::string("setDisplayMode"))) { Py::Callable method(vp.getAttr(std::string("setDisplayMode"))); Py::Tuple args(1); args.setItem(0, Py::String(ModeName)); Py::String str(method.apply(args)); return str.as_std_string(); } } } catch (Py::Exception&) { Base::PyException e; // extract the Python error text const char* name = object->getObject()->Label.getValue(); Base::Console().Error("ViewProviderPythonFeature::setDisplayMode (%s): %s\n", name, e.what()); } return ModeName; }
void ViewProviderPythonFeatureImp::attach(App::DocumentObject *pcObject) { // Run the attach method of the proxy object. Base::PyGILStateLocker lock; try { App::Property* proxy = object->getPropertyByName("Proxy"); if (proxy && proxy->getTypeId() == App::PropertyPythonObject::getClassTypeId()) { Py::Object vp = static_cast<App::PropertyPythonObject*>(proxy)->getValue(); if (vp.hasAttr(std::string("attach"))) { if (vp.hasAttr("__object__")) { Py::Callable method(vp.getAttr(std::string("attach"))); Py::Tuple args(0); method.apply(args); } else { Py::Callable method(vp.getAttr(std::string("attach"))); Py::Tuple args(1); args.setItem(0, Py::Object(object->getPyObject(), true)); method.apply(args); } // #0000415: Now simulate a property change event to call // claimChildren if implemented. pcObject->Label.touch(); } } } catch (Py::Exception&) { Base::PyException e; // extract the Python error text const char* name = object->getObject()->Label.getValue(); Base::Console().Error("ViewProviderPythonFeature::attach (%s): %s\n", name, e.what()); } }
void ViewProviderPythonFeatureImp::onChanged(const App::Property* prop) { // Run the onChanged method of the proxy object. Base::PyGILStateLocker lock; try { App::Property* proxy = object->getPropertyByName("Proxy"); if (proxy && proxy->getTypeId() == App::PropertyPythonObject::getClassTypeId()) { Py::Object vp = static_cast<App::PropertyPythonObject*>(proxy)->getValue(); if (vp.hasAttr(std::string("onChanged"))) { if (vp.hasAttr("__object__")) { Py::Callable method(vp.getAttr(std::string("onChanged"))); Py::Tuple args(1); std::string prop_name = object->getName(prop); args.setItem(0, Py::String(prop_name)); method.apply(args); } else { Py::Callable method(vp.getAttr(std::string("onChanged"))); Py::Tuple args(2); args.setItem(0, Py::Object(object->getPyObject(), true)); std::string prop_name = object->getName(prop); args.setItem(1, Py::String(prop_name)); method.apply(args); } } } } catch (Py::Exception&) { Base::PyException e; // extract the Python error text const char* name = object->getObject()->Label.getValue(); Base::Console().Error("ViewProviderPythonFeature::onChanged (%s): %s\n", name, e.what()); } }
std::string ViewProviderPythonFeatureImp::getElement(const SoDetail *det) const { // Run the onChanged method of the proxy object. Base::PyGILStateLocker lock; try { App::Property* proxy = object->getPropertyByName("Proxy"); if (proxy && proxy->getTypeId() == App::PropertyPythonObject::getClassTypeId()) { Py::Object vp = static_cast<App::PropertyPythonObject*>(proxy)->getValue(); if (vp.hasAttr(std::string("getElement"))) { PyObject* pivy = 0; // Note: As there is no ref'counting mechanism for the SoDetail class we must // pass '0' as the last parameter so that the Python object does not 'own' // the detail object. pivy = Base::Interpreter().createSWIGPointerObj("pivy.coin", "SoDetail *", (void*)det, 0); Py::Callable method(vp.getAttr(std::string("getElement"))); Py::Tuple args(1); args.setItem(0, Py::Object(pivy, true)); Py::String name(method.apply(args)); return (std::string)name; } } } catch (const Base::Exception& e) { e.ReportException(); } catch (Py::Exception&) { Base::PyException e; // extract the Python error text e.ReportException(); } return ""; }
void ViewProviderPythonFeatureObserver::slotAppendObject(const Gui::ViewProvider& obj) { if (!obj.isDerivedFrom(Gui::ViewProviderDocumentObject::getClassTypeId())) return; const Gui::ViewProviderDocumentObject& vp = static_cast<const Gui::ViewProviderDocumentObject&>(obj); const App::DocumentObject* docobj = vp.getObject(); App::Document* doc = docobj->getDocument(); std::map<const App::Document*, ObjectProxy>::iterator it = proxyMap.find(doc); if (it != proxyMap.end()) { ObjectProxy::iterator jt = it->second.find(docobj); if (jt != it->second.end()) { Base::PyGILStateLocker lock; try { App::Property* prop = vp.getPropertyByName("Proxy"); if (prop && prop->isDerivedFrom(App::PropertyPythonObject::getClassTypeId())) { static_cast<App::PropertyPythonObject*>(prop)->fromString(jt->second); static_cast<App::PropertyPythonObject*>(prop)->touch(); it->second.erase(jt); } } catch (Py::Exception& e) { e.clear(); } } // all cached objects of the documents are already destroyed else { it->second.clear(); } } }
/** * Sets the document objects and their view providers to manipulate the material. */ void DlgMaterialPropertiesImp::setViewProviders(const std::vector<Gui::ViewProvider*>& Obj) { Objects = Obj; for (std::vector<ViewProvider*>::iterator it= Objects.begin();it!=Objects.end();++it) { App::Property* prop = (*it)->getPropertyByName(material.c_str()); if (prop && prop->getTypeId().isDerivedFrom(App::PropertyMaterial::getClassTypeId())) { App::PropertyMaterial* ShapeMaterial = (App::PropertyMaterial*)prop; App::Material mat = ShapeMaterial->getValue(); int r = int(mat.ambientColor.r * 255.0f); int g = int(mat.ambientColor.g * 255.0f); int b = int(mat.ambientColor.b * 255.0f); ambientColor->setColor( QColor(r,g,b) ); r = int(mat.diffuseColor.r * 255.0f); g = int(mat.diffuseColor.g * 255.0f); b = int(mat.diffuseColor.b * 255.0f); diffuseColor->setColor( QColor(r,g,b) ); r = int(mat.emissiveColor.r * 255.0f); g = int(mat.emissiveColor.g * 255.0f); b = int(mat.emissiveColor.b * 255.0f); emissiveColor->setColor( QColor(r,g,b) ); r = int(mat.specularColor.r * 255.0f); g = int(mat.specularColor.g * 255.0f); b = int(mat.specularColor.b * 255.0f); specularColor->setColor( QColor(r,g,b) ); shininess->blockSignals(true); shininess->setValue((int)(100.0f * (mat.shininess+0.001f))); shininess->blockSignals(false); break; } } }
SoDetail* ViewProviderPythonFeatureImp::getDetail(const char* name) const { // Run the onChanged method of the proxy object. Base::PyGILStateLocker lock; try { App::Property* proxy = object->getPropertyByName("Proxy"); if (proxy && proxy->getTypeId() == App::PropertyPythonObject::getClassTypeId()) { Py::Object vp = static_cast<App::PropertyPythonObject*>(proxy)->getValue(); if (vp.hasAttr(std::string("getDetail"))) { Py::Callable method(vp.getAttr(std::string("getDetail"))); Py::Tuple args(1); args.setItem(0, Py::String(name)); Py::Object det(method.apply(args)); void* ptr = 0; Base::Interpreter().convertSWIGPointerObj("pivy.coin", "SoDetail *", det.ptr(), &ptr, 0); SoDetail* detail = reinterpret_cast<SoDetail*>(ptr); return detail ? detail->copy() : 0; } } } catch (const Base::Exception& e) { e.ReportException(); } catch (Py::Exception&) { Base::PyException e; // extract the Python error text e.ReportException(); } return 0; }
std::vector<App::DocumentObject*> ViewProviderPythonFeatureImp::claimChildren(const std::vector<App::DocumentObject*>& base) const { std::vector<App::DocumentObject*> children; Base::PyGILStateLocker lock; try { App::Property* proxy = object->getPropertyByName("Proxy"); if (proxy && proxy->getTypeId() == App::PropertyPythonObject::getClassTypeId()) { Py::Object vp = static_cast<App::PropertyPythonObject*>(proxy)->getValue(); if (vp.hasAttr(std::string("claimChildren"))) { Py::Callable method(vp.getAttr(std::string("claimChildren"))); Py::Tuple args; Py::Sequence list(method.apply(args)); 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(); children.push_back(obj); } } } else { children = base; } } } catch (Py::Exception&) { Base::PyException e; // extract the Python error text e.ReportException(); } return children; }
int DocumentObjectProtectorPy::setattr(const char * attr, const Py::Object & value) { if (!_dp) { std::string s; std::ostringstream s_out; s_out << "Cannot access attribute '" << attr << "' of deleted object"; throw Py::RuntimeError(s_out.str()); } else { App::DocumentObject* obj = _dp->getObject(); App::Property* prop = obj->getPropertyByName(attr); if (!prop) { std::string s; std::ostringstream s_out; s_out << "No such attribute '" << attr << "'"; throw Py::AttributeError(s_out.str()); } Base::PyGILStateRelease unlock; std::unique_ptr<App::Property> copy(static_cast<App::Property*> (prop->getTypeId().createInstance())); if (PyObject_TypeCheck(value.ptr(), DocumentObjectProtectorPy::type_object())) { copy->setPyObject(static_cast<const DocumentObjectProtectorPy*>(value.ptr())->getObject().ptr()); } else { copy->setPyObject(value.ptr()); } return _dp->setProperty(attr, *copy) ? 0 : -1; } }
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); float fTolerance = 0.1f; MeshObject global_mesh; PY_TRY { Py::Sequence list(object); Base::Type meshId = Base::Type::fromName("Mesh::Feature"); Base::Type partId = Base::Type::fromName("Part::Feature"); 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(); if (obj->getTypeId().isDerivedFrom(meshId)) { const MeshObject& mesh = static_cast<Mesh::Feature*>(obj)->Mesh.getValue(); MeshCore::MeshKernel kernel = mesh.getKernel(); kernel.Transform(mesh.getTransform()); if (global_mesh.countFacets() == 0) global_mesh.setKernel(kernel); else global_mesh.addMesh(kernel); } else if (obj->getTypeId().isDerivedFrom(partId)) { App::Property* shape = obj->getPropertyByName("Shape"); Base::Reference<MeshObject> mesh(new MeshObject()); if (shape && shape->getTypeId().isDerivedFrom(App::PropertyComplexGeoData::getClassTypeId())) { std::vector<Base::Vector3d> aPoints; std::vector<Data::ComplexGeoData::Facet> aTopo; static_cast<App::PropertyComplexGeoData*>(shape)->getFaces(aPoints, aTopo,fTolerance); mesh->addFacets(aTopo, aPoints); if (global_mesh.countFacets() == 0) global_mesh = *mesh; else global_mesh.addMesh(*mesh); } } else { Base::Console().Message("'%s' is not a mesh or shape, export will be ignored.\n", obj->Label.getValue()); } } } // export mesh compound global_mesh.save(EncodedName.c_str()); } PY_CATCH; Py_Return; }
/** * Sets the 'LineWidth' property of all selected view providers. */ void TaskAppearance::on_spinLineWidth_valueChanged(int linewidth) { std::vector<Gui::ViewProvider*> Provider = getSelection(); for (std::vector<Gui::ViewProvider*>::iterator It= Provider.begin();It!=Provider.end();++It) { App::Property* prop = (*It)->getPropertyByName("LineWidth"); if (prop && prop->getTypeId().isDerivedFrom(App::PropertyFloat::getClassTypeId())) { App::PropertyFloat* LineWidth = (App::PropertyFloat*)prop; LineWidth->setValue((float)linewidth); } } }
void ViewProviderPythonFeatureImp::finishRestoring() { App::Property* proxy = object->getPropertyByName("Proxy"); if (proxy && proxy->getTypeId() == App::PropertyPythonObject::getClassTypeId()) { Py::Object vp = static_cast<App::PropertyPythonObject*>(proxy)->getValue(); if (vp.ptr() == Py::_None()) { object->show(); static_cast<App::PropertyPythonObject*>(proxy)->setValue(Py::Int(1)); } } }
/** * Sets the 'Transparency' property of all selected view providers. */ void TaskAppearance::on_spinTransparency_valueChanged(int transparency) { std::vector<Gui::ViewProvider*> Provider = getSelection(); for (std::vector<Gui::ViewProvider*>::iterator It= Provider.begin();It!=Provider.end();++It) { App::Property* prop = (*It)->getPropertyByName("Transparency"); if (prop && prop->getTypeId().isDerivedFrom(App::PropertyInteger::getClassTypeId())) { App::PropertyInteger* Transparency = (App::PropertyInteger*)prop; Transparency->setValue(transparency); } } }
void StdCmdPlacement::activated(int iMsg) { std::vector<App::DocumentObject*> sel = Gui::Selection().getObjectsOfType(App::GeoFeature::getClassTypeId()); Gui::Dialog::TaskPlacement* plm = new Gui::Dialog::TaskPlacement(); if (!sel.empty()) { App::Property* prop = sel.front()->getPropertyByName("Placement"); if (prop && prop->getTypeId() == App::PropertyPlacement::getClassTypeId()) plm->setPlacement(static_cast<App::PropertyPlacement*>(prop)->getValue()); } Gui::Control().showDialog(plm); }
/** * Sets the 'PointSize' property of all selected view providers. */ void TaskAppearance::on_spinPointSize_valueChanged(int pointsize) { std::vector<Gui::ViewProvider*> Provider = getSelection(); for (std::vector<Gui::ViewProvider*>::iterator It= Provider.begin();It!=Provider.end();++It) { App::Property* prop = (*It)->getPropertyByName("PointSize"); if (prop && prop->getTypeId().isDerivedFrom(App::PropertyFloat::getClassTypeId())) { App::PropertyFloat* PointSize = (App::PropertyFloat*)prop; PointSize->setValue((float)pointsize); } } }
void Part2DObject::Restore(Base::XMLReader &reader) { //override generic restoration to convert Support property from PropertyLinkSub to PropertyLinkSubList reader.readElement("Properties"); int Cnt = reader.getAttributeAsInteger("Count"); for (int i=0 ;i<Cnt ;i++) { reader.readElement("Property"); const char* PropName = reader.getAttribute("name"); const char* TypeName = reader.getAttribute("type"); App::Property* prop = getPropertyByName(PropName); // NOTE: We must also check the type of the current property because a // subclass of PropertyContainer might change the type of a property but // not its name. In this case we would force to read-in a wrong property // type and the behaviour would be undefined. try { if(prop){ if (strcmp(prop->getTypeId().getName(), TypeName) == 0){ prop->Restore(reader); } else if (prop->isDerivedFrom(App::PropertyLinkSubList::getClassTypeId())){ //reading legacy Support - when the Support could only be a single flat face. App::PropertyLinkSub tmp; if (0 == strcmp(tmp.getTypeId().getName(),TypeName)) { tmp.setContainer(this); tmp.Restore(reader); static_cast<App::PropertyLinkSubList*>(prop)->setValue(tmp.getValue(), tmp.getSubValues()); } this->MapMode.setValue(Attacher::mmFlatFace); } } } catch (const Base::XMLParseException&) { throw; // re-throw } catch (const Base::Exception &e) { Base::Console().Error("%s\n", e.what()); } catch (const std::exception &e) { Base::Console().Error("%s\n", e.what()); } catch (const char* e) { Base::Console().Error("%s\n", e); } #ifndef FC_DEBUG catch (...) { Base::Console().Error("PropertyContainer::Restore: Unknown C++ exception thrown"); } #endif reader.readEndElement("Property"); } reader.readEndElement("Properties"); }
/** * Sets the 'Display' property of all selected view providers. */ void TaskAppearance::on_changeMode_activated(const QString& s) { Gui::WaitCursor wc; std::vector<Gui::ViewProvider*> Provider = getSelection(); for (std::vector<Gui::ViewProvider*>::iterator It= Provider.begin();It!=Provider.end();++It) { App::Property* prop = (*It)->getPropertyByName("DisplayMode"); if (prop && prop->getTypeId() == App::PropertyEnumeration::getClassTypeId()) { App::PropertyEnumeration* Display = (App::PropertyEnumeration*)prop; Display->setValue((const char*)s.toLatin1()); } } }
void ProfileBased::Restore(Base::XMLReader& reader) { reader.readElement("Properties"); int Cnt = reader.getAttributeAsInteger("Count"); for (int i=0 ;i<Cnt ;i++) { reader.readElement("Property"); const char* PropName = reader.getAttribute("name"); const char* TypeName = reader.getAttribute("type"); App::Property* prop = getPropertyByName(PropName); // NOTE: We must also check the type of the current property because a // subclass of PropertyContainer might change the type of a property but // not its name. In this case we would force to read-in a wrong property // type and the behaviour would be undefined. try { //check if we load the old sketch property if(!prop && (strcmp("Sketch", PropName) == 0) && (strcmp("App::PropertyLink", TypeName) == 0)) { std::vector<std::string> vec; // read my element reader.readElement("Link"); // get the value of my attribute std::string name = reader.getAttribute("value"); if (name != "") { App::Document* document = getDocument(); DocumentObject* object = document ? document->getObject(name.c_str()) : 0; Profile.setValue(object, vec); } else { Profile.setValue(0, vec); } } else if (prop && strcmp(prop->getTypeId().getName(), TypeName) == 0) prop->Restore(reader); } catch (const Base::XMLParseException&) { throw; // re-throw } catch (const Base::Exception &e) { Base::Console().Error("%s\n", e.what()); } catch (const std::exception &e) { Base::Console().Error("%s\n", e.what()); } catch (const char* e) { Base::Console().Error("%s\n", e); } reader.readEndElement("Property"); } reader.readEndElement("Properties"); }
void Primitive::Restore(Base::XMLReader &reader) { reader.readElement("Properties"); int Cnt = reader.getAttributeAsInteger("Count"); for (int i=0 ;i<Cnt ;i++) { reader.readElement("Property"); const char* PropName = reader.getAttribute("name"); const char* TypeName = reader.getAttribute("type"); App::Property* prop = getPropertyByName(PropName); // For #0001652 the property types of many primitive features have changed // from PropertyFloat or PropertyFloatConstraint to a more meaningful type. // In order to load older project files there must be checked in case the // types don't match if both inherit from PropertyFloat because all derived // classes do not re-implement the Save/Restore methods. try { if (prop && strcmp(prop->getTypeId().getName(), TypeName) == 0) { prop->Restore(reader); } else if (prop) { Base::Type inputType = Base::Type::fromName(TypeName); if (prop->getTypeId().isDerivedFrom(App::PropertyFloat::getClassTypeId()) && inputType.isDerivedFrom(App::PropertyFloat::getClassTypeId())) { // Do not directly call the property's Restore method in case the implmentation // has changed. So, create a temporary PropertyFloat object and assign the value. App::PropertyFloat floatProp; floatProp.Restore(reader); static_cast<App::PropertyFloat*>(prop)->setValue(floatProp.getValue()); } } } catch (const Base::XMLParseException&) { throw; // re-throw } catch (const Base::Exception &e) { Base::Console().Error("%s\n", e.what()); } catch (const std::exception &e) { Base::Console().Error("%s\n", e.what()); } catch (const char* e) { Base::Console().Error("%s\n", e); } #ifndef FC_DEBUG catch (...) { Base::Console().Error("Primitive::Restore: Unknown C++ exception thrown"); } #endif reader.readEndElement("Property"); } reader.readEndElement("Properties"); }
QIcon ViewProviderPythonFeatureImp::getIcon() const { // default icon //static QPixmap px = BitmapFactory().pixmap("Tree_Python"); // Run the getIcon method of the proxy object. Base::PyGILStateLocker lock; try { App::Property* proxy = object->getPropertyByName("Proxy"); if (proxy && proxy->getTypeId() == App::PropertyPythonObject::getClassTypeId()) { Py::Object vp = static_cast<App::PropertyPythonObject*>(proxy)->getValue(); if (vp.hasAttr(std::string("getIcon"))) { Py::Callable method(vp.getAttr(std::string("getIcon"))); Py::Tuple args(0); Py::String str(method.apply(args)); std::string content = str.as_std_string(); QPixmap icon; // Check if the passed string is a filename, otherwise treat as xpm data QFileInfo fi(QString::fromAscii(content.c_str())); if (fi.isFile() && fi.exists()) { icon.load(fi.absoluteFilePath()); } else { QByteArray ary; int strlen = (int)content.size(); ary.resize(strlen); for (int j=0; j<strlen; j++) ary[j]=content[j]; // Make sure to remove crap around the XPM data QList<QByteArray> lines = ary.split('\n'); QByteArray buffer; buffer.reserve(ary.size()+lines.size()); for (QList<QByteArray>::iterator it = lines.begin(); it != lines.end(); ++it) { QByteArray trim = it->trimmed(); if (!trim.isEmpty()) { buffer.append(trim); buffer.append('\n'); } } icon.loadFromData(buffer, "XPM"); } if (!icon.isNull()) { return icon; } } } } catch (Py::Exception&) { Base::PyException e; // extract the Python error text Base::Console().Error("ViewProviderPythonFeature::getIcon: %s\n", e.what()); } return QIcon(); }
void PropertyView::slotAppendDynamicProperty(const App::Property& prop) { App::PropertyContainer* parent = prop.getContainer(); if (parent->isHidden(&prop) || prop.testStatus(App::Property::Hidden)) return; if (parent && parent->isDerivedFrom(App::DocumentObject::getClassTypeId())) { propertyEditorData->appendProperty(prop); } else if (parent && parent->isDerivedFrom(Gui::ViewProvider::getClassTypeId())) { propertyEditorView->appendProperty(prop); } }
/** * Sets the current shininess. */ void DlgMaterialPropertiesImp::on_shininess_valueChanged(int sh) { float shininess = (float)sh/100.0f; for (std::vector<ViewProvider*>::iterator it= Objects.begin();it!=Objects.end();++it) { App::Property* prop = (*it)->getPropertyByName(material.c_str()); if (prop && prop->getTypeId().isDerivedFrom(App::PropertyMaterial::getClassTypeId())) { App::PropertyMaterial* ShapeMaterial = (App::PropertyMaterial*)prop; App::Material mat = ShapeMaterial->getValue(); mat.shininess = shininess; ShapeMaterial->setValue(mat); } } }
void DlgDisplayPropertiesImp::setColorPlot(const std::vector<Gui::ViewProvider*>& views) { bool material = false; for (std::vector<Gui::ViewProvider*>::const_iterator it = views.begin(); it != views.end(); ++it) { App::Property* prop = (*it)->getPropertyByName("TextureMaterial"); if (prop && prop->getTypeId() == App::PropertyMaterial::getClassTypeId()) { material = true; break; } } buttonColorPlot->setEnabled(material); }
void DlgDisplayPropertiesImp::on_buttonLineColor_changed() { std::vector<Gui::ViewProvider*> Provider = getSelection(); QColor s = buttonLineColor->color(); App::Color c(s.red()/255.0,s.green()/255.0,s.blue()/255.0); for (std::vector<Gui::ViewProvider*>::iterator It= Provider.begin();It!=Provider.end();++It) { App::Property* prop = (*It)->getPropertyByName("LineColor"); if (prop && prop->getTypeId() == App::PropertyColor::getClassTypeId()) { App::PropertyColor* ShapeColor = (App::PropertyColor*)prop; ShapeColor->setValue(c); } } }
void Transformed::Restore(Base::XMLReader &reader) { reader.readElement("Properties"); int Cnt = reader.getAttributeAsInteger("Count"); for (int i=0 ;i<Cnt ;i++) { reader.readElement("Property"); const char* PropName = reader.getAttribute("name"); const char* TypeName = reader.getAttribute("type"); App::Property* prop = getPropertyByName(PropName); // The property 'Angle' of PolarPattern has changed from PropertyFloat // to PropertyAngle and the property 'Length' has changed to PropertyLength. try { if (prop && strcmp(prop->getTypeId().getName(), TypeName) == 0) { prop->Restore(reader); } else if (prop) { Base::Type inputType = Base::Type::fromName(TypeName); if (prop->getTypeId().isDerivedFrom(App::PropertyFloat::getClassTypeId()) && inputType.isDerivedFrom(App::PropertyFloat::getClassTypeId())) { // Do not directly call the property's Restore method in case the implmentation // has changed. So, create a temporary PropertyFloat object and assign the value. App::PropertyFloat floatProp; floatProp.Restore(reader); static_cast<App::PropertyFloat*>(prop)->setValue(floatProp.getValue()); } } } catch (const Base::XMLParseException&) { throw; // re-throw } catch (const Base::Exception &e) { Base::Console().Error("%s\n", e.what()); } catch (const std::exception &e) { Base::Console().Error("%s\n", e.what()); } catch (const char* e) { Base::Console().Error("%s\n", e); } #ifndef FC_DEBUG catch (...) { Base::Console().Error("Primitive::Restore: Unknown C++ exception thrown"); } #endif reader.readEndElement("Property"); } reader.readEndElement("Properties"); }
PyObject* PropertyContainerPy::getPropertyByName(PyObject *args) { char *pstr; if (!PyArg_ParseTuple(args, "s", &pstr)) // convert args: Python->C return NULL; // NULL triggers exception App::Property* prop = getPropertyContainerPtr()->getPropertyByName(pstr); if (prop) { return prop->getPyObject(); } else { PyErr_Format(PyExc_AttributeError, "Property container has no property '%s'", pstr); return NULL; } }
void customEvent(QEvent* e) { PropertyEvent* pe = static_cast<PropertyEvent*>(e); std::set<const Gui::ViewProvider*>::iterator it = viewMap.find(pe->view); // Make sure that the object hasn't been deleted in the meantime (#0001522) if (it != viewMap.end()) { viewMap.erase(it); App::Property* prop = pe->view->getPropertyByName("Proxy"); if (prop && prop->isDerivedFrom(App::PropertyPythonObject::getClassTypeId())) { prop->Paste(*pe->prop); } } delete pe->prop; }
PyObject* DocumentObjectGroupPy::addObject(PyObject *args) { PyObject *object; if (!PyArg_ParseTuple(args, "O!", &(DocumentObjectPy::Type), &object)) // convert args: Python->C return NULL; // NULL triggers exception DocumentObjectPy* docObj = static_cast<DocumentObjectPy*>(object); if (!docObj->getDocumentObjectPtr() || !docObj->getDocumentObjectPtr()->getNameInDocument()) { PyErr_SetString(Base::BaseExceptionFreeCADError, "Cannot add an invalid object"); return NULL; } if (docObj->getDocumentObjectPtr()->getDocument() != getDocumentObjectGroupPtr()->getDocument()) { PyErr_SetString(Base::BaseExceptionFreeCADError, "Cannot add an object from another document to this group"); return NULL; } if (docObj->getDocumentObjectPtr() == this->getDocumentObjectGroupPtr()) { PyErr_SetString(Base::BaseExceptionFreeCADError, "Cannot add a group object to itself"); return NULL; } if (docObj->getDocumentObjectPtr()->getTypeId().isDerivedFrom(DocumentObjectGroup::getClassTypeId())) { App::DocumentObjectGroup* docGrp = static_cast<DocumentObjectGroup*>(docObj->getDocumentObjectPtr()); if (this->getDocumentObjectGroupPtr()->isChildOf(docGrp)) { PyErr_SetString(Base::BaseExceptionFreeCADError, "Cannot add a group object to a child group"); return NULL; } } DocumentObjectGroup* grp = getDocumentObjectGroupPtr(); if (grp->getTypeId().isDerivedFrom(App::DocumentObjectGroupPython::getClassTypeId())) { DocumentObjectGroupPython* grppy = static_cast<DocumentObjectGroupPython*>(grp); App::Property* proxy = grppy->getPropertyByName("Proxy"); if (proxy && proxy->getTypeId() == App::PropertyPythonObject::getClassTypeId()) { Py::Object vp = static_cast<App::PropertyPythonObject*>(proxy)->getValue(); if (vp.hasAttr(std::string("addObject"))) { Py::Callable method(vp.getAttr(std::string("addObject"))); // check which this method belongs to to avoid an infinite recursion if (method.getAttr(std::string("__self__")) != Py::Object(this)) { Py::Tuple args(1); args[0] = Py::Object(object); method.apply(args); Py_Return; } } } } grp->addObject(docObj->getDocumentObjectPtr()); Py_Return; }