void PropertyFileIncluded::Restore(Base::XMLReader &reader) { reader.readElement("FileIncluded"); if (reader.hasAttribute("file")) { string file (reader.getAttribute("file") ); if (!file.empty()) { // initate a file read reader.addFile(file.c_str(),this); // is in the document transient path aboutToSetValue(); _cValue = getDocTransientPath() + "/" + file; _BaseFileName = file; hasSetValue(); } } // section is XML stream else if (reader.hasAttribute("data")) { string file (reader.getAttribute("data") ); if (!file.empty()) { // is in the document transient path aboutToSetValue(); _cValue = getDocTransientPath() + "/" + file; reader.readBinFile(_cValue.c_str()); reader.readEndElement("FileIncluded"); _BaseFileName = file; hasSetValue(); } } }
void PropertyPythonObject::restoreObject(Base::XMLReader &reader) { Base::PyGILStateLocker lock; try { PropertyContainer* parent = this->getContainer(); if (reader.hasAttribute("object")) { if (strcmp(reader.getAttribute("object"),"yes") == 0) { Py::Object obj = Py::asObject(parent->getPyObject()); this->object.setAttr("__object__", obj); } } if (reader.hasAttribute("vobject")) { if (strcmp(reader.getAttribute("vobject"),"yes") == 0) { Py::Object obj = Py::asObject(parent->getPyObject()); this->object.setAttr("__vobject__", obj); } } } catch (Py::Exception& e) { e.clear(); } catch (const Base::Exception& e) { Base::Console().Error("%s\n",e.what()); } catch (...) { Base::Console().Error("Critical error in PropertyPythonObject::restoreObject\n"); } }
void PropertyColumnWidths::Restore(Base::XMLReader &reader) { int Cnt; // Column info reader.readElement("ColumnInfo"); Cnt = reader.hasAttribute("Count") ? reader.getAttributeAsInteger("Count") : 0; for (int i = 0; i < Cnt; i++) { reader.readElement("Column"); const char* name = reader.hasAttribute("name") ? reader.getAttribute("name") : 0; const char * width = reader.hasAttribute("width") ? reader.getAttribute("width") : 0; try { if (name && width) { int col = App::decodeColumn(name); int colWidth = atoi(width); setValue(col, colWidth); } } catch (...) { // Something is wrong, skip this column } } reader.readEndElement("ColumnInfo"); }
void DynamicProperty::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"); Property* prop = getPropertyByName(PropName); try { if (!prop) { short attribute = 0; bool readonly = false, hidden = false; const char *group=0, *doc=0, *attr=0, *ro=0, *hide=0; if (reader.hasAttribute("group")) group = reader.getAttribute("group"); if (reader.hasAttribute("doc")) doc = reader.getAttribute("doc"); if (reader.hasAttribute("attr")) { attr = reader.getAttribute("attr"); if (attr) attribute = attr[0]-48; } if (reader.hasAttribute("ro")) { ro = reader.getAttribute("ro"); if (ro) readonly = (ro[0]-48) != 0; } if (reader.hasAttribute("hide")) { hide = reader.getAttribute("hide"); if (hide) hidden = (hide[0]-48) != 0; } prop = addDynamicProperty(TypeName, PropName, group, doc, attribute, readonly, hidden); } } catch(const Base::Exception& e) { // only handle this exception type Base::Console().Warning(e.what()); } //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. // Don't read transient properties if (!(getPropertyType(prop) & Prop_Transient)) { if (prop && strcmp(prop->getTypeId().getName(), TypeName) == 0) prop->Restore(reader); else if (prop) Base::Console().Warning("%s: Overread data for property %s of type %s, expected type is %s\n", pc->getTypeId().getName(), prop->getName(), prop->getTypeId().getName(), TypeName); else Base::Console().Warning("%s: No property found with name %s and type %s\n", pc->getTypeId().getName(), PropName, TypeName); } reader.readEndElement("Property"); } reader.readEndElement("Properties"); }
void PropertyRowHeights::Restore(Base::XMLReader &reader) { int Cnt; // Row info reader.readElement("RowInfo"); Cnt = reader.hasAttribute("Count") ? reader.getAttributeAsInteger("Count") : 0; for (int i = 0; i < Cnt; i++) { reader.readElement("Row"); const char* name = reader.hasAttribute("name") ? reader.getAttribute("name") : 0; const char * height = reader.hasAttribute("height") ? reader.getAttribute("height") : 0; try { if (name && height) { int row = App::decodeRow(name); int rowHeight = atoi(height); setValue(row, rowHeight); } } catch (...) { // Something is wrong, skip this row } } reader.readEndElement("RowInfo"); }
void PropertyColorList::Restore(Base::XMLReader &reader) { reader.readElement("ColorList"); if (reader.hasAttribute("file")) { std::string file (reader.getAttribute("file")); if (!file.empty()) { // initate a file read reader.addFile(file.c_str(),this); } } }
void PropertyExpressionEngine::Restore(Base::XMLReader &reader) { reader.readElement("ExpressionEngine"); int count = reader.getAttributeAsFloat("count"); for (int i = 0; i < count; ++i) { DocumentObject * docObj = freecad_dynamic_cast<DocumentObject>(getContainer()); reader.readElement("Expression"); ObjectIdentifier path = ObjectIdentifier::parse(docObj, reader.getAttribute("path")); boost::shared_ptr<Expression> expression(ExpressionParser::parse(docObj, reader.getAttribute("expression"))); const char * comment = reader.hasAttribute("comment") ? reader.getAttribute("comment") : 0; setValue(path, expression, comment); } reader.readEndElement("ExpressionEngine"); }
void PropertyEnumeration::Restore(Base::XMLReader &reader) { // read my Element reader.readElement("Integer"); // get the value of my Attribute long val = reader.getAttributeAsInteger("value"); if (reader.hasAttribute("CustomEnum")) { reader.readElement("CustomEnumList"); int count = reader.getAttributeAsInteger("count"); std::vector<std::string> values(count); for(int i = 0; i < count; i++) { reader.readElement("Enum"); values[i] = reader.getAttribute("value"); } reader.readEndElement("CustomEnumList"); _CustomEnum = true; setEnumVector(values); } setValue(val); }
void PropertyPythonObject::Restore(Base::XMLReader &reader) { reader.readElement("Python"); if (reader.hasAttribute("file")) { std::string file(reader.getAttribute("file")); reader.addFile(file.c_str(),this); } else { bool load_json=false; bool load_pickle=false; bool load_failed=false; std::string buffer = reader.getAttribute("value"); if (reader.hasAttribute("encoded") && strcmp(reader.getAttribute("encoded"),"yes") == 0) { buffer = Base::base64_decode(buffer); } else { buffer = decodeValue(buffer); } Base::PyGILStateLocker lock; try { boost::regex pickle("^\\(i(\\w+)\\n(\\w+)\\n"); boost::match_results<std::string::const_iterator> what; std::string::const_iterator start, end; start = buffer.begin(); end = buffer.end(); if (reader.hasAttribute("module") && reader.hasAttribute("class")) { Py::Module mod(PyImport_ImportModule(reader.getAttribute("module")),true); PyObject* cls = mod.getAttr(reader.getAttribute("class")).ptr(); #if PY_MAJOR_VERSION >= 3 if (PyType_Check(cls)) { #else if (PyClass_Check(cls)) { this->object = PyInstance_NewRaw(cls, 0); } else if (PyType_Check(cls)) { #endif this->object = PyType_GenericAlloc((PyTypeObject*)cls, 0); } else { throw Py::TypeError("neither class nor type object"); } load_json = true; } else if (boost::regex_search(start, end, what, pickle)) { std::string nam = std::string(what[1].first, what[1].second); std::string cls = std::string(what[2].first, what[2].second); Py::Module mod(PyImport_ImportModule(nam.c_str()),true); #if PY_MAJOR_VERSION >= 3 this->object = PyObject_CallObject(mod.getAttr(cls).ptr(), NULL); #else this->object = PyInstance_NewRaw(mod.getAttr(cls).ptr(), 0); #endif load_pickle = true; buffer = std::string(what[2].second, end); } else if (reader.hasAttribute("json")) { load_json = true; } } catch (Py::Exception&) { Base::PyException e; // extract the Python error text e.ReportException(); this->object = Py::None(); load_failed = true; } aboutToSetValue(); if (load_json) this->fromString(buffer); else if (load_pickle) this->loadPickle(buffer); else if (!load_failed) Base::Console().Warning("PropertyPythonObject::Restore: unsupported serialisation: %s\n", buffer.c_str()); restoreObject(reader); hasSetValue(); } }
void Cell::restore(Base::XMLReader &reader) { const char* style = reader.hasAttribute("style") ? reader.getAttribute("style") : 0; const char* alignment = reader.hasAttribute("alignment") ? reader.getAttribute("alignment") : 0; const char* content = reader.hasAttribute("content") ? reader.getAttribute("content") : ""; const char* foregroundColor = reader.hasAttribute("foregroundColor") ? reader.getAttribute("foregroundColor") : 0; const char* backgroundColor = reader.hasAttribute("backgroundColor") ? reader.getAttribute("backgroundColor") : 0; const char* displayUnit = reader.hasAttribute("displayUnit") ? reader.getAttribute("displayUnit") : 0; const char* alias = reader.hasAttribute("alias") ? reader.getAttribute("alias") : 0; const char* rowSpan = reader.hasAttribute("rowSpan") ? reader.getAttribute("rowSpan") : 0; const char* colSpan = reader.hasAttribute("colSpan") ? reader.getAttribute("colSpan") : 0; // Don't trigger multiple updates below; wait until everything is loaded by calling unfreeze() below. PropertySheet::AtomicPropertyChange signaller(*owner); if (content) { setContent(content); } if (style) { using namespace boost; std::set<std::string> styleSet; escaped_list_separator<char> e('\0', '|', '\0'); std::string line = std::string(style); tokenizer<escaped_list_separator<char> > tok(line, e); for(tokenizer<escaped_list_separator<char> >::iterator i = tok.begin(); i != tok.end();++i) styleSet.insert(*i); setStyle(styleSet); } if (alignment) { int alignmentCode = 0; using namespace boost; escaped_list_separator<char> e('\0', '|', '\0'); std::string line = std::string(alignment); tokenizer<escaped_list_separator<char> > tok(line, e); for(tokenizer<escaped_list_separator<char> >::iterator i = tok.begin(); i != tok.end();++i) alignmentCode = decodeAlignment(*i, alignmentCode); setAlignment(alignmentCode); } if (foregroundColor) { App::Color color = decodeColor(foregroundColor, App::Color(0, 0, 0, 1)); setForeground(color); } if (backgroundColor) { App::Color color = decodeColor(backgroundColor, App::Color(1, 1, 1, 1)); setBackground(color); } if (displayUnit) setDisplayUnit(displayUnit); if (alias) setAlias(alias); if (rowSpan || colSpan) { int rs = rowSpan ? atoi(rowSpan) : 1; int cs = colSpan ? atoi(colSpan) : 1; setSpans(rs, cs); } }
void DynamicProperty::Restore(Base::XMLReader &reader) { //first all extensions must be initialised so that they can handle their properties if(this->pc->isDerivedFrom(App::ExtensionContainer::getClassTypeId())) static_cast<App::ExtensionContainer*>(this->pc)->restoreExtensions(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"); Property* prop = getPropertyByName(PropName); try { if (!prop) { short attribute = 0; bool readonly = false, hidden = false; const char *group=0, *doc=0, *attr=0, *ro=0, *hide=0; if (reader.hasAttribute("group")) group = reader.getAttribute("group"); if (reader.hasAttribute("doc")) doc = reader.getAttribute("doc"); if (reader.hasAttribute("attr")) { attr = reader.getAttribute("attr"); if (attr) attribute = attr[0]-48; } if (reader.hasAttribute("ro")) { ro = reader.getAttribute("ro"); if (ro) readonly = (ro[0]-48) != 0; } if (reader.hasAttribute("hide")) { hide = reader.getAttribute("hide"); if (hide) hidden = (hide[0]-48) != 0; } prop = addDynamicProperty(TypeName, PropName, group, doc, attribute, readonly, hidden); } } catch(const Base::Exception& e) { // only handle this exception type Base::Console().Warning(e.what()); } //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. // Don't read transient properties if (!(getPropertyType(prop) & Prop_Transient)) { if (prop && strcmp(prop->getTypeId().getName(), TypeName) == 0) { try { 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()); } #ifndef FC_DEBUG catch (...) { Base::Console().Error("DynamicProperty::Restore: Unknown C++ exception thrown"); } #endif } else if (prop) { Base::Console().Warning("%s: Overread data for property %s of type %s, expected type is %s\n", pc->getTypeId().getName(), prop->getName(), prop->getTypeId().getName(), TypeName); } else { Base::Console().Warning("%s: No property found with name %s and type %s\n", pc->getTypeId().getName(), PropName, TypeName); } } reader.readEndElement("Property"); } reader.readEndElement("Properties"); }