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"); }
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 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"); }
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"); }
//DVA is still Source PropertyLink so needs different logic vs DV::Restore void DrawViewArch::Restore(Base::XMLReader &reader) { // this is temporary code for backwards compat (within v0.17). can probably be deleted once there are no development // fcstd files with old property types in use. 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* schemaProp = getPropertyByName(PropName); try { if(schemaProp){ if (strcmp(schemaProp->getTypeId().getName(), TypeName) == 0){ //if the property type in obj == type in schema schemaProp->Restore(reader); //nothing special to do } else if (strcmp(PropName, "Source") == 0) { App::PropertyLinkGlobal glink; App::PropertyLink link; if (strcmp(glink.getTypeId().getName(),TypeName) == 0) { //property in file is plg glink.setContainer(this); glink.Restore(reader); if (glink.getValue() != nullptr) { static_cast<App::PropertyLink*>(schemaProp)->setScope(App::LinkScope::Global); static_cast<App::PropertyLink*>(schemaProp)->setValue(glink.getValue()); } } else if (strcmp(link.getTypeId().getName(),TypeName) == 0) { //property in file is pl link.setContainer(this); link.Restore(reader); if (link.getValue() != nullptr) { static_cast<App::PropertyLink*>(schemaProp)->setScope(App::LinkScope::Global); static_cast<App::PropertyLink*>(schemaProp)->setValue(link.getValue()); } } else { // has Source prop isn't PropertyLink or PropertyLinkGlobal! Base::Console().Log("DrawViewArch::Restore - old Document Source is weird: %s\n", TypeName); // no idea } } else { Base::Console().Log("DrawViewArch::Restore - old Document has unknown Property\n"); } } } 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\n"); } #endif reader.readEndElement("Property"); } reader.readEndElement("Properties"); }
/** * This method was added for backward-compatibility. In former versions * of Box we had the properties x,y,z and l,h,w which have changed to * Location -- as replacement for x,y and z and Length, Height and Width. */ void Box::Restore(Base::XMLReader &reader) { reader.readElement("Properties"); int Cnt = reader.getAttributeAsInteger("Count"); bool location_xyz = false; bool location_axis = false; bool distance_lhw = false; Base::Placement plm; App::PropertyDistance x,y,z; App::PropertyDistance l,w,h; App::PropertyVector Axis, Location; Axis.setValue(0.0f,0.0f,1.0f); 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); if (!prop) { // in case this comes from an old document we must use the new properties if (strcmp(PropName, "l") == 0) { distance_lhw = true; prop = &l; } else if (strcmp(PropName, "w") == 0) { distance_lhw = true; prop = &h; // by mistake w was considered as height } else if (strcmp(PropName, "h") == 0) { distance_lhw = true; prop = &w; // by mistake h was considered as width } else if (strcmp(PropName, "x") == 0) { location_xyz = true; prop = &x; } else if (strcmp(PropName, "y") == 0) { location_xyz = true; prop = &y; } else if (strcmp(PropName, "z") == 0) { location_xyz = true; prop = &z; } else if (strcmp(PropName, "Axis") == 0) { location_axis = true; prop = &Axis; } else if (strcmp(PropName, "Location") == 0) { location_axis = true; prop = &Location; } } else if (strcmp(PropName, "Length") == 0 && strcmp(TypeName,"PropertyDistance") == 0) { distance_lhw = true; prop = &l; } else if (strcmp(PropName, "Height") == 0 && strcmp(TypeName,"PropertyDistance") == 0) { distance_lhw = true; prop = &h; } else if (strcmp(PropName, "Width") == 0 && strcmp(TypeName,"PropertyDistance") == 0) { distance_lhw = true; prop = &w; } // 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. std::string tn = TypeName; if (strcmp(TypeName,"PropertyDistance") == 0) // missing prefix App:: tn = std::string("App::") + tn; if (prop && strcmp(prop->getTypeId().getName(), tn.c_str()) == 0) prop->Restore(reader); reader.readEndElement("Property"); } if (distance_lhw) { this->Length.setValue(l.getValue()); this->Height.setValue(h.getValue()); this->Width.setValue(w.getValue()); } // for 0.7 releases or earlier if (location_xyz) { plm.setPosition(Base::Vector3d(x.getValue(),y.getValue(),z.getValue())); this->Placement.setValue(this->Placement.getValue() * plm); this->Shape.setStatus(App::Property::User1, true); // override the shape's location later on } // for 0.8 releases else if (location_axis) { Base::Vector3d d = Axis.getValue(); Base::Vector3d p = Location.getValue(); Base::Rotation rot(Base::Vector3d(0.0,0.0,1.0), Base::Vector3d(d.x,d.y,d.z)); plm.setRotation(rot); plm.setPosition(Base::Vector3d(p.x,p.y,p.z)); this->Placement.setValue(this->Placement.getValue() * plm); this->Shape.setStatus(App::Property::User1, true); // override the shape's location later on } reader.readEndElement("Properties"); }