void Chamfer::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); try { if (prop && strcmp(prop->getTypeId().getName(), TypeName) == 0) { prop->Restore(reader); } else if (prop && strcmp(TypeName,"App::PropertyFloatConstraint") == 0 && strcmp(prop->getTypeId().getName(), "App::PropertyQuantityConstraint") == 0) { App::PropertyFloatConstraint p; p.Restore(reader); static_cast<App::PropertyQuantityConstraint*>(prop)->setValue(p.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()); } reader.readEndElement("Property"); } reader.readEndElement("Properties"); }
QString ViewProviderInspection::inspectDistance(const SoPickedPoint* pp) const { QString info; const SoDetail* detail = pp->getDetail(pp->getPath()->getTail()); if (detail && detail->getTypeId() == SoFaceDetail::getClassTypeId()) { // get the distances of the three points of the picked facet const SoFaceDetail * facedetail = static_cast<const SoFaceDetail*>(detail); App::Property* pDistance = this->pcObject->getPropertyByName("Distances"); if (pDistance && pDistance->getTypeId() == Inspection::PropertyDistanceList::getClassTypeId()) { Inspection::PropertyDistanceList* dist = static_cast<Inspection::PropertyDistanceList*>(pDistance); int index1 = facedetail->getPoint(0)->getCoordinateIndex(); int index2 = facedetail->getPoint(1)->getCoordinateIndex(); int index3 = facedetail->getPoint(2)->getCoordinateIndex(); float fVal1 = (*dist)[index1]; float fVal2 = (*dist)[index2]; float fVal3 = (*dist)[index3]; App::Property* pActual = this->pcObject->getPropertyByName("Actual"); if (pActual && pActual->getTypeId().isDerivedFrom( App::PropertyLink::getClassTypeId())) { float fSearchRadius = this->search_radius; if (fVal1 > fSearchRadius || fVal2 > fSearchRadius || fVal3 > fSearchRadius) { info = QObject::tr("Distance: > %1").arg(fSearchRadius); } else if (fVal1 < -fSearchRadius || fVal2 < -fSearchRadius || fVal3 < -fSearchRadius) { info = QObject::tr("Distance: < %1").arg(-fSearchRadius); } else { const SbVec3f& v1 = this->pcCoords->point[index1]; const SbVec3f& v2 = this->pcCoords->point[index2]; const SbVec3f& v3 = this->pcCoords->point[index3]; const SbVec3f& p = pp->getObjectPoint(); // get the weights float w1, w2, w3; calcWeights(v1,v2,v3,p,w1,w2,w3); float fVal = w1*fVal1+w2*fVal2+w3*fVal3; info = QObject::tr("Distance: %1").arg(fVal); } } } } else if (detail && detail->getTypeId() == SoPointDetail::getClassTypeId()) { // safe downward cast, know the type const SoPointDetail * pointdetail = static_cast<const SoPointDetail*>(detail); // get the distance of the picked point int index = pointdetail->getCoordinateIndex(); App::Property* prop = this->pcObject->getPropertyByName("Distances"); if (prop && prop->getTypeId() == Inspection::PropertyDistanceList::getClassTypeId()) { Inspection::PropertyDistanceList* dist = static_cast<Inspection::PropertyDistanceList*>(prop); float fVal = (*dist)[index]; info = QObject::tr("Distance: %1").arg(fVal); } } return info; }
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"); }
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"); }
ViewProviderPythonFeatureImp::ValueT ViewProviderPythonFeatureImp::canDropObject(App::DocumentObject* obj) 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("canDropObject"))) { Py::Callable method(vp.getAttr(std::string("canDropObject"))); Py::Tuple args(1); args.setItem(0, Py::Object(obj->getPyObject(), true)); Py::Boolean ok(method.apply(args)); return static_cast<bool>(ok) ? Accepted : Rejected; } else { return NotImplemented; } } } catch (Py::Exception&) { Base::PyException e; // extract the Python error text e.ReportException(); } return Rejected; }
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::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 ""; }
/** * 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; } } }
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(0); 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 Base::Console().Error("ViewProviderPythonFeature::claimChildren: %s\n", e.what()); } 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; } }
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()); } }
void Sheet::updateAlias(CellAddress key) { std::string alias; Property * prop = props.getDynamicPropertyByName(key.toString().c_str()); if (!prop) return; Cell * cell = getCell(key); if (cell && cell->getAlias(alias)) { App::Property * aliasProp = props.getDynamicPropertyByName(alias.c_str()); /* Update or create alias? */ if (aliasProp) { // Type of alias and property must always be the same if (aliasProp->getTypeId() != prop->getTypeId()) { props.removeDynamicProperty(alias.c_str()); aliasProp = 0; } } if (!aliasProp) aliasProp = props.addDynamicProperty(prop->getTypeId().getName(), alias.c_str(), 0, 0, Prop_ReadOnly | Prop_Transient, true, true); aliasProp->Paste(*prop); } }
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()); } }
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 TaskAppearance::setDisplayModes(const std::vector<Gui::ViewProvider*>& views) { QStringList commonModes, modes; for (std::vector<Gui::ViewProvider*>::const_iterator it = views.begin(); it != views.end(); ++it) { App::Property* prop = (*it)->getPropertyByName("DisplayMode"); if (prop && prop->getTypeId() == App::PropertyEnumeration::getClassTypeId()) { App::PropertyEnumeration* display = static_cast<App::PropertyEnumeration*>(prop); if (!display->getEnums()) return; const std::vector<std::string>& value = display->getEnumVector(); if (it == views.begin()) { for (std::vector<std::string>::const_iterator jt = value.begin(); jt != value.end(); ++jt) commonModes << QLatin1String(jt->c_str()); } else { for (std::vector<std::string>::const_iterator jt = value.begin(); jt != value.end(); ++jt) { if (commonModes.contains(QLatin1String(jt->c_str()))) modes << QLatin1String(jt->c_str()); } commonModes = modes; modes.clear(); } } } ui->changeMode->clear(); ui->changeMode->addItems(commonModes); ui->changeMode->setDisabled(commonModes.isEmpty()); // find the display mode to activate for (std::vector<Gui::ViewProvider*>::const_iterator it = views.begin(); it != views.end(); ++it) { App::Property* prop = (*it)->getPropertyByName("DisplayMode"); if (prop && prop->getTypeId() == App::PropertyEnumeration::getClassTypeId()) { App::PropertyEnumeration* display = static_cast<App::PropertyEnumeration*>(prop); QString activeMode = QString::fromLatin1(display->getValueAsString()); int index = ui->changeMode->findText(activeMode); if (index != -1) { ui->changeMode->setCurrentIndex(index); break; } } } }
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); } } }
/** * 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); } } }
/** * 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 DlgEvaluateMeshImp::slotChangedObject(const App::DocumentObject& Obj, const App::Property& Prop) { // if the current mesh object was modified update everything if (&Obj == d->meshFeature && Prop.getTypeId() == Mesh::PropertyMeshKernel::getClassTypeId()) { removeViewProviders(); cleanInformation(); showInformation(); d->self_intersections.clear(); } else if (Obj.getTypeId().isDerivedFrom(Mesh::Feature::getClassTypeId())) { // if the label has changed update the entry in the list if (Prop.getTypeId() == App::PropertyString::getClassTypeId() && strcmp(Prop.getName(), "Label") == 0) { QString label = QString::fromUtf8(Obj.Label.getValue()); QString name = QString::fromAscii(Obj.getNameInDocument()); int index = meshNameButton->findData(name); meshNameButton->setItemText(index, label); } } }
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"); }
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); }
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 '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"); }
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 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); }
/** * 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::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); } } }