kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Implemented DocumentReader for GuiDocument.xml reading. Final

Browse Source
This commit is contained in:
AgCaliva
2023-06-30 20:50:36 -03:00
parent 1db4bcf374
commit 9cf1cdadbc
20 changed files with 1036 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/App/Document.cpp
View File

@@ -87,6 +87,7 @@ recompute path. Also, it enables more complicated dependencies beyond trees.
#include <Base/FileInfo.h>
#include <Base/TimeInfo.h>
#include <Base/Reader.h>
#include <Base/DocumentReader.h>
#include <Base/Writer.h>
#include <Base/Tools.h>
#include <Base/Uuid.h>
@@ -1227,7 +1228,6 @@ Document::readObjects(Base::XMLReader& reader)
// read the object types
reader.readElement("Objects");
int Cnt = reader.getAttributeAsInteger("Count");
if(!reader.hasAttribute(FC_ATTR_DEPENDENCIES))
d->partialLoadObjects.clear();
else if(!d->partialLoadObjects.empty()) {
@@ -2023,12 +2023,12 @@ void Document::restore (const char *filename,
// without GUI. But if available then follow after all data files of the App document.
signalRestoreDocument(reader);
reader.readFiles(zipstream);
if (reader.testStatus(Base::XMLReader::ReaderStatus::PartialRestore)) {
setStatus(Document::PartialRestore, true);
Base::Console().Error("There were errors while loading the file. Some data might have been modified or not recovered at all. Look above for more specific information about the objects involved.\n");
}
if(!delaySignal)
afterRestore(true);
}

30
src/App/DynamicProperty.cpp
View File

@@ -26,6 +26,7 @@
#include <Base/Reader.h>
#include <Base/Tools.h>
#include <Base/Writer.h>
#include <Base/DocumentReader.h>
#include "DynamicProperty.h"
#include "Application.h"
@@ -322,6 +323,35 @@ Property *DynamicProperty::restore(PropertyContainer &pc,
return addDynamicProperty(pc,TypeName, PropName, group, doc, attribute, readonly, hidden);
}
Property *DynamicProperty::restore(PropertyContainer &pc,
const char *PropName, const char *TypeName, Base::DocumentReader &reader, XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *PropertyDOM)
{
const char* group_cstr = reader.GetAttribute(PropertyDOM,"group");
if(!group_cstr)
return nullptr;
short attribute = 0;
bool readonly = false, hidden = false;
const char* doc_cstr = reader.GetAttribute(PropertyDOM,"doc");
const char* attr_cstr = reader.GetAttribute(PropertyDOM,"attr");
if(attr_cstr){
std::istringstream str(attr_cstr);
str >> attribute;
}
const char* ro_cstr = reader.GetAttribute(PropertyDOM,"ro");
if(ro_cstr)
readonly = (ro_cstr[0]-48) != 0;
const char* hide_cstr = reader.GetAttribute(PropertyDOM,"hide");
if(hide_cstr)
hidden = (hide_cstr[0]-48) != 0;
return addDynamicProperty(pc,TypeName, PropName, group_cstr, doc_cstr, attribute, readonly, hidden);
}
DynamicProperty::PropData DynamicProperty::getDynamicPropertyData(const Property *prop) const
{
auto &index = props.get<1>();

11
src/App/DynamicProperty.h
View File

@@ -33,6 +33,15 @@
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <xercesc/util/XercesDefs.hpp>
XERCES_CPP_NAMESPACE_BEGIN
class DOMNode;
class DOMElement;
// class DefaultHandler;
// class SAX2XMLReader;
XERCES_CPP_NAMESPACE_END
namespace Base {
@@ -145,6 +154,8 @@ public:
Property *restore(PropertyContainer &pc,
const char *PropName, const char *TypeName, Base::XMLReader &reader);
Property *restore(PropertyContainer &pc,
const char *PropName, const char *TypeName, Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *PropertyDOM);
struct PropData {
Property* property;

20
src/App/Extension.cpp
View File

@@ -34,7 +34,6 @@
#include "ExtensionPython.h"
#include <ExtensionPy.h>
/* We do not use a standard property macro for type initiation. The reason is that we have the first
* PropertyData in the extension chain, there is no parent property data.
*/
@@ -79,7 +78,6 @@ void Extension::initExtensionType(Base::Type type) {
}
void Extension::initExtension(ExtensionContainer* obj) {
if (m_extensionType.isBad())
throw Base::RuntimeError("Extension: Extension type not set");
@@ -205,6 +203,24 @@ bool Extension::extensionHandleChangedPropertyType(Base::XMLReader &reader, cons
return false;
};
bool Extension::extensionHandleChangedPropertyName(Base::DocumentReader &reader, const char * TypeName, const char *PropName)
{
(void) reader;
(void) TypeName;
(void) PropName;
return false;
};
bool Extension::extensionHandleChangedPropertyType(Base::DocumentReader &reader, const char * TypeName, Property * prop)
{
(void) reader;
(void) TypeName;
(void) prop;
return false;
};
namespace App {
EXTENSION_PROPERTY_SOURCE_TEMPLATE(App::ExtensionPython, App::ExtensionPython::Inherited)

4
src/App/Extension.h
View File

@@ -290,6 +290,10 @@ protected:
virtual bool extensionHandleChangedPropertyName(Base::XMLReader &reader, const char * TypeName, const char *PropName);
/// returns true if the property type change was handled by the extension.
virtual bool extensionHandleChangedPropertyType(Base::XMLReader &reader, const char * TypeName, Property * prop);
/// returns true if the property name change was handled by the extension.
virtual bool extensionHandleChangedPropertyName(Base::DocumentReader &reader, const char * TypeName, const char *PropName);
/// returns true if the property type change was handled by the extension.
virtual bool extensionHandleChangedPropertyType(Base::DocumentReader &reader, const char * TypeName, Property * prop);
friend class App::ExtensionContainer;

149
src/App/ExtensionContainer.cpp
View File

@@ -32,6 +32,11 @@
#include "ExtensionContainer.h"
#include <Base/DocumentReader.h>
#ifndef _PreComp_
# include <xercesc/dom/DOM.hpp>
//# include <xercesc/parsers/XercesDOMParser.hpp>
#endif
using namespace App;
@@ -49,7 +54,6 @@ ExtensionContainer::~ExtensionContainer() {
}
void ExtensionContainer::registerExtension(Base::Type extension, Extension* ext) {
if(ext->getExtendedContainer() != this)
throw Base::ValueError("ExtensionContainer::registerExtension: Extension has not this as base object");
@@ -308,16 +312,15 @@ void ExtensionContainer::Restore(Base::XMLReader& reader) {
App::PropertyContainer::Restore(reader);
}
void ExtensionContainer::Restore(Base::DocumentReader& reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *viewProviderEl) {
void ExtensionContainer::Restore(Base::DocumentReader& reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *containerEl) {
//restore dynamic extensions.
//Note 1: The extension element must be read first, before all other object elements. That is
// needed as the element works together with an object element attribute, which would be
// cleared if another attribute is read first
//Note 2: This must happen before the py object of this container is used, as only in the
// pyobject constructor the extension methods are added to the container.
restoreExtensions(reader,viewProviderEl);
//TODO NOW:
//App::PropertyContainer::Restore(reader);
restoreExtensions(reader,containerEl);
App::PropertyContainer::Restore(reader,containerEl);
}
void ExtensionContainer::saveExtensions(Base::Writer& writer) const {
@@ -365,70 +368,80 @@ void ExtensionContainer::saveExtensions(Base::Writer& writer) const {
writer.decInd();
}
void ExtensionContainer::restoreExtensions(Base::DocumentReader& reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *viewProviderEl) {
void ExtensionContainer::restoreExtensions(Base::DocumentReader& reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *containerEl) {
//Dynamic extensions are optional (also because they are introduced late into the document format)
//and hence it is possible that the element does not exist. As we cannot check for the existence of
//an element a object attribute is set if extensions are available. Here we check that
//attribute, and only if it exists the extensions element will be available.
const char* expanded_cstr = reader.GetAttribute(viewProviderEl,"expanded");
const char* expanded_cstr = reader.GetAttribute(containerEl,"expanded");
if(!expanded_cstr)
return;
auto ExtensionsDOM = reader.FindElement(viewProviderEl,"Extensions");
auto ExtensionsDOM = reader.FindElement(containerEl,"Extensions");
if(ExtensionsDOM){
const char* cnt_cstr = reader.GetAttribute(ExtensionsDOM,"Count");
if(cnt_cstr){
long Cnt = reader.ContentToInt( cnt_cstr );
for (int i=0 ;i<Cnt ;i++) {
auto ExtensionDOM_i = reader.FindElement(ExtensionsDOM,"Extension");
const char* type_cstr = reader.GetAttribute(ExtensionDOM_i,"type");
const char* name_cstr = reader.GetAttribute(ExtensionDOM_i,"name");
try {
App::Extension* ext = getExtension(name_cstr);
if(!ext) {
//get the extension type asked for
Base::Type extension = Base::Type::fromName(type_cstr);
if (extension.isBad() || !extension.isDerivedFrom(App::Extension::getExtensionClassTypeId())) {
std::stringstream str;
str << "No extension found of type '" << type_cstr << "'" << std::ends;
throw Base::TypeError(str.str());
}
//register the extension
ext = static_cast<App::Extension*>(extension.createInstance());
//check if this really is a python extension!
if (!ext->isPythonExtension()) {
delete ext;
std::stringstream str;
str << "Extension is not a python addable version: '" << type_cstr << "'" << std::ends;
throw Base::TypeError(str.str());
}
ext->initExtension(this);
if( strcmp(ext->getExtensionTypeId().getName(), type_cstr) == 0 )
ext->extensionRestore(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);
}
#ifndef FC_DEBUG
catch (...) {
Base::Console().Error("ExtensionContainer::Restore: Unknown C++ exception thrown\n");
}
#endif
auto prev_ExtensionDOM = reader.FindElement(ExtensionsDOM,"Extension");
readExtension(reader,prev_ExtensionDOM);
for (int i=1 ;i<Cnt ;i++) {
auto ExtensionDOM_i = reader.FindNextElement(prev_ExtensionDOM,"Extension");
readExtension(reader,ExtensionDOM_i);
prev_ExtensionDOM = ExtensionDOM_i;
}
}
}
}
void ExtensionContainer::readExtension(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ExtensionDOM){
const char* type_cstr = reader.GetAttribute(ExtensionDOM,"type");
const char* name_cstr = reader.GetAttribute(ExtensionDOM,"name");
try {
App::Extension* ext = getExtension(name_cstr);
if(!ext) {
//get the extension type asked for
Base::Type extension = Base::Type::fromName(type_cstr);
if (extension.isBad() || !extension.isDerivedFrom(App::Extension::getExtensionClassTypeId())) {
std::stringstream str;
str << "No extension found of type '" << type_cstr << "'" << std::ends;
throw Base::TypeError(str.str());
}
//register the extension
ext = static_cast<App::Extension*>(extension.createInstance());
//check if this really is a python extension!
if (!ext->isPythonExtension()) {
delete ext;
std::stringstream str;
str << "Extension is not a python addable version: '" << type_cstr << "'" << std::ends;
throw Base::TypeError(str.str());
}
ext->initExtension(this);
if( strcmp(ext->getExtensionTypeId().getName(), type_cstr) == 0 )
ext->extensionRestore(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);
}
#ifndef FC_DEBUG
catch (...) {
Base::Console().Error("ExtensionContainer::Restore: Unknown C++ exception thrown\n");
}
#endif
}
void ExtensionContainer::restoreExtensions(Base::XMLReader& reader) {
//Dynamic extensions are optional (also because they are introduced late into the document format)
@@ -508,6 +521,20 @@ void ExtensionContainer::handleChangedPropertyName(Base::XMLReader &reader, cons
PropertyContainer::handleChangedPropertyName(reader, TypeName, PropName);
}
void ExtensionContainer::handleChangedPropertyName(Base::DocumentReader &reader, const char * TypeName, const char *PropName)
{
//inform all extensions about changed property name. This includes all properties from the
//extended object (this) as well as all extension properties
for(const auto& entry : _extensions) {
bool handled = entry.second->extensionHandleChangedPropertyName(reader, TypeName, PropName);
if(handled)
return; // one property change needs only be handled once
}
PropertyContainer::handleChangedPropertyName(reader, TypeName, PropName);
}
void ExtensionContainer::handleChangedPropertyType(Base::XMLReader &reader, const char * TypeName, Property * prop)
{
//inform all extensions about changed property type. This includes all properties from the
@@ -521,3 +548,17 @@ void ExtensionContainer::handleChangedPropertyType(Base::XMLReader &reader, cons
PropertyContainer::handleChangedPropertyType(reader, TypeName, prop);
}
void ExtensionContainer::handleChangedPropertyType(Base::DocumentReader &reader, const char * TypeName, Property * prop)
{
//inform all extensions about changed property type. This includes all properties from the
//extended object (this) as well as all extension properties
for(const auto& entry : _extensions) {
bool handled = entry.second->extensionHandleChangedPropertyType(reader, TypeName, prop);
if(handled)
return; // one property change needs only be handled once
}
PropertyContainer::handleChangedPropertyType(reader, TypeName, prop);
}

8
src/App/ExtensionContainer.h
View File

@@ -185,13 +185,13 @@ public:
void Save(Base::Writer& writer) const override;
void Restore(Base::XMLReader& reader) override;
void Restore(Base::DocumentReader& reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *viewProviderEl);
void Restore(Base::DocumentReader& reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *containerEl);
//those methods save/restore the dynamic extensions without handling properties, which is something
//done by the default Save/Restore methods.
void saveExtensions(Base::Writer& writer) const;
void restoreExtensions(Base::XMLReader& reader);
void restoreExtensions(Base::DocumentReader& reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *viewProviderEl);
void restoreExtensions(Base::DocumentReader& reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *containerEl);
/** Extends the rules for handling property name changed, so that extensions are given an opportunity to handle it.
* If an extension handles a change, neither the rest of the extensions, nor the container itself get to handle it.
@@ -201,6 +201,7 @@ public:
* If no extension handles the request, then the containers handleChangedPropertyName() is called.
*/
virtual void handleChangedPropertyName(Base::XMLReader &reader, const char * TypeName, const char *PropName) override;
virtual void handleChangedPropertyName(Base::DocumentReader &reader, const char * TypeName, const char *PropName) override;
/** Extends the rules for handling property type changed, so that extensions are given an opportunity to handle it.
* If an extension handles a change, neither the rest of the extensions, nor the container itself get to handle it.
*
@@ -209,6 +210,9 @@ public:
* If no extension handles the request, then the containers handleChangedPropertyType() is called.
*/
virtual void handleChangedPropertyType(Base::XMLReader &reader, const char * TypeName, Property * prop) override;
virtual void handleChangedPropertyType(Base::DocumentReader &reader, const char * TypeName, Property * prop) override;
void readExtension(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ExtensionDOM);
private:
//stored extensions

219
src/App/PropertyContainer.cpp
View File

@@ -32,6 +32,10 @@
#include "PropertyContainer.h"
#include <Base/DocumentReader.h>
#ifndef _PreComp_
# include <xercesc/dom/DOM.hpp>
#endif
FC_LOG_LEVEL_INIT("App",true,true)
@@ -75,8 +79,9 @@ App::Property* PropertyContainer::addDynamicProperty(
Property *PropertyContainer::getPropertyByName(const char* name) const
{
auto prop = dynamicProps.getDynamicPropertyByName(name);
if(prop)
if(prop){
return prop;
}
return getPropertyData().getPropertyByName(this,name);
}
@@ -199,6 +204,13 @@ void PropertyContainer::handleChangedPropertyName(Base::XMLReader &reader, const
(void)PropName;
}
void PropertyContainer::handleChangedPropertyName(Base::DocumentReader &reader, const char * TypeName, const char *PropName)
{
(void)reader;
(void)TypeName;
(void)PropName;
}
/**
* @brief PropertyContainer::handleChangedPropertyType is called during restore to possibly
* fix reading of older versions of the property container. This method is typically called
@@ -218,6 +230,13 @@ void PropertyContainer::handleChangedPropertyType(XMLReader &reader, const char
(void)prop;
}
void PropertyContainer::handleChangedPropertyType(DocumentReader &reader, const char *TypeName, Property *prop)
{
(void)reader;
(void)TypeName;
(void)prop;
}
PropertyData PropertyContainer::propertyData;
void PropertyContainer::Save (Base::Writer &writer) const
@@ -321,6 +340,7 @@ void PropertyContainer::Restore(Base::XMLReader &reader)
if(reader.hasAttribute("TransientCount"))
transientCount = reader.getAttributeAsUnsigned("TransientCount");
for (int i=0;i<transientCount; ++i) {
reader.readElement("_Property");
Property* prop = getPropertyByName(reader.getAttribute("name"));
@@ -340,8 +360,9 @@ void PropertyContainer::Restore(Base::XMLReader &reader)
// type and the behaviour would be undefined.
try {
auto prop = getPropertyByName(PropName.c_str());
if(!prop || prop->getContainer() != this)
if(!prop || prop->getContainer() != this){
prop = dynamicProps.restore(*this,PropName.c_str(),TypeName.c_str(),reader);
}
decltype(Property::StatusBits) status;
if(reader.hasAttribute("status")) {
@@ -403,101 +424,115 @@ void PropertyContainer::Restore(Base::XMLReader &reader)
reader.readEndElement("Properties");
}
void PropertyContainer::Restore(Base::DocumentReader &reader)
void PropertyContainer::Restore(Base::DocumentReader &reader, XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *containerEl)
{
//TODO NOW
Base::Console().Error("PropertyContainer::Restore: DocumentReader\n");
reader.clearPartialRestoreProperty();
/*
reader.clearPartialRestoreProperty();
reader.readElement("Properties");
int Cnt = reader.getAttributeAsInteger("Count");
auto PropertiesDOM = reader.FindElement(containerEl,"Properties");
const char* count_cstr = reader.GetAttribute(PropertiesDOM,"Count");
if(count_cstr){
long Cnt = reader.ContentToInt( count_cstr );
const char* TransientCount_cstr = reader.GetAttribute(PropertiesDOM,"TransientCount");
int transientCount = 0;
if(TransientCount_cstr)
transientCount = reader.ContentToUnsigned( TransientCount_cstr );
for (int i=0;i<transientCount; ++i) {
auto _PropertyDOM = reader.FindElement(PropertiesDOM,"_Property");
const char* name_cstr = reader.GetAttribute(_PropertyDOM,"name");
const char* status_cstr = reader.GetAttribute(_PropertyDOM,"status");
Property* prop = getPropertyByName(name_cstr);
if(prop)
FC_TRACE("restore transient '" << prop->getName() << "'");
if(prop && status_cstr){
int u_status = reader.ContentToUnsigned( status_cstr );
prop->setStatusValue(u_status);
}
}
if(Cnt){
auto prev_PropertyDOM = reader.FindElement(PropertiesDOM,"Property");
readProperty(reader,prev_PropertyDOM);
for (int i=1 ;i<Cnt ;i++) {
auto PropertyDOM_i = reader.FindNextElement(prev_PropertyDOM,"Property");
readProperty(reader,PropertyDOM_i);
prev_PropertyDOM = PropertyDOM_i;
}
}
}
}
int transientCount = 0;
if(reader.hasAttribute("TransientCount"))
transientCount = reader.getAttributeAsUnsigned("TransientCount");
for (int i=0;i<transientCount; ++i) {
reader.readElement("_Property");
Property* prop = getPropertyByName(reader.getAttribute("name"));
if(prop)
FC_TRACE("restore transient '" << prop->getName() << "'");
if(prop && reader.hasAttribute("status"))
prop->setStatusValue(reader.getAttributeAsUnsigned("status"));
}
for (int i=0 ;i<Cnt ;i++) {
reader.readElement("Property");
std::string PropName = reader.getAttribute("name");
std::string TypeName = reader.getAttribute("type");
// 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 {
auto prop = getPropertyByName(PropName.c_str());
if(!prop || prop->getContainer() != this)
prop = dynamicProps.restore(*this,PropName.c_str(),TypeName.c_str(),reader);
decltype(Property::StatusBits) status;
if(reader.hasAttribute("status")) {
status = decltype(status)(reader.getAttributeAsUnsigned("status"));
if(prop)
prop->setStatusValue(status.to_ulong());
}
// name and type match
if (prop && strcmp(prop->getTypeId().getName(), TypeName.c_str()) == 0) {
if (!prop->testStatus(Property::Transient)
&& !status.test(Property::Transient)
&& !status.test(Property::PropTransient)
&& !prop->testStatus(Property::PropTransient))
{
FC_TRACE("restore property '" << prop->getName() << "'");
prop->Restore(reader);
}else
FC_TRACE("skip transient '" << prop->getName() << "'");
}
// name matches but not the type
else if (prop) {
handleChangedPropertyType(reader, TypeName.c_str(), prop);
}
// name doesn't match, the sub-class then has to know
// if the property has been renamed or removed
else {
handleChangedPropertyName(reader, TypeName.c_str(), PropName.c_str());
}
if (reader.testStatus(Base::XMLReader::ReaderStatus::PartialRestoreInProperty)) {
Base::Console().Error("Property %s of type %s was subject to a partial restore.\n",PropName.c_str(),TypeName.c_str());
reader.clearPartialRestoreProperty();
}
}
catch (const Base::XMLParseException&) {
throw; // re-throw
}
catch (const Base::RestoreError &) {
reader.setPartialRestore(true);
reader.clearPartialRestoreProperty();
Base::Console().Error("Property %s of type %s was subject to a partial restore.\n",PropName.c_str(),TypeName.c_str());
}
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);
}
// 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.
void PropertyContainer::readProperty(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *PropertyDOM){
const char* name_cstr = reader.GetAttribute(PropertyDOM,"name");
const char* type_cstr = reader.GetAttribute(PropertyDOM,"type");
try {
auto prop = getPropertyByName(name_cstr);
if(!prop || prop->getContainer() != this){
prop = dynamicProps.restore(*this,name_cstr,type_cstr,reader,PropertyDOM);
}
decltype(Property::StatusBits) status;
const char* status_cstr = reader.GetAttribute(PropertyDOM,"status");
if(status_cstr){
int u_status = reader.ContentToUnsigned( status_cstr );
status = decltype(status)(u_status);
if(prop)
prop->setStatusValue(status.to_ulong());
}
// name and type match
if (prop && strcmp(prop->getTypeId().getName(), type_cstr) == 0) {
if (!prop->testStatus(Property::Transient)
&& !status.test(Property::Transient)
&& !status.test(Property::PropTransient)
&& !prop->testStatus(Property::PropTransient))
{
FC_TRACE("restore property '" << prop->getName() << "'");
prop->Restore(reader,PropertyDOM);
}else
FC_TRACE("skip transient '" << prop->getName() << "'");
}
// name matches but not the type
else if (prop) {
handleChangedPropertyType(reader, type_cstr, prop);
}
// name doesn't match, the sub-class then has to know
// if the property has been renamed or removed
else {
handleChangedPropertyName(reader, type_cstr, name_cstr);
}
if (reader.testStatus(Base::DocumentReader::ReaderStatus::PartialRestoreInProperty)) {
Base::Console().Error("Property %s of type %s was subject to a partial restore.\n",name_cstr,type_cstr);
reader.clearPartialRestoreProperty();
}
}
catch (const Base::XMLParseException&) {
throw; // re-throw
}
catch (const Base::RestoreError &) {
reader.setPartialRestore(true);
reader.clearPartialRestoreProperty();
Base::Console().Error("Property %s of type %s was subject to a partial restore.\n",name_cstr,type_cstr);
}
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");
}
catch (...) {
Base::Console().Error("PropertyContainer::Restore: Unknown C++ exception thrown\n");
}
#endif
reader.readEndElement("Property");
}
reader.readEndElement("Properties");
*/
}
void PropertyContainer::onPropertyStatusChanged(const Property &prop, unsigned long oldStatus)

15
src/App/PropertyContainer.h
View File

@@ -30,6 +30,16 @@
#include "DynamicProperty.h"
#include <xercesc/util/XercesDefs.hpp>
XERCES_CPP_NAMESPACE_BEGIN
class DOMNode;
class DOMElement;
// class DefaultHandler;
// class SAX2XMLReader;
XERCES_CPP_NAMESPACE_END
namespace Base {
class Writer;
}
@@ -220,7 +230,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader) override;
void Restore(Base::DocumentReader &reader, XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *containerEl) override;
virtual void editProperty(const char * /*propName*/) {}
@@ -248,11 +258,14 @@ protected:
virtual void handleChangedPropertyName(Base::XMLReader &reader, const char * TypeName, const char *PropName);
virtual void handleChangedPropertyType(Base::XMLReader &reader, const char * TypeName, Property * prop);
virtual void handleChangedPropertyName(Base::DocumentReader &reader, const char * TypeName, const char *PropName);
virtual void handleChangedPropertyType(Base::DocumentReader &reader, const char * TypeName, Property * prop);
private:
// forbidden
PropertyContainer(const PropertyContainer&);
PropertyContainer& operator = (const PropertyContainer&);
void readProperty(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *PropertyDOM);
protected:
DynamicProperty dynamicProps;

357
src/App/PropertyStandard.cpp
View File

@@ -23,6 +23,10 @@
#include "PreCompiled.h"
#ifndef _PreComp_
# include <xercesc/dom/DOM.hpp>
#endif
#include <boost/algorithm/string/predicate.hpp>
#include <boost/math/special_functions/round.hpp>
@@ -30,6 +34,7 @@
#include <Base/Exception.h>
#include <Base/Interpreter.h>
#include <Base/Reader.h>
#include <Base/DocumentReader.h>
#include <Base/Writer.h>
#include <Base/Quantity.h>
#include <Base/Stream.h>
@@ -117,6 +122,20 @@ void PropertyInteger::Restore(Base::XMLReader &reader)
setValue(reader.getAttributeAsInteger("value"));
}
void PropertyInteger::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
// read my Element
auto IntegerDOM = reader.FindElement(ContainerDOM,"Integer");
if(IntegerDOM){
// get the value of my Attribute
const char* value_cstr = reader.GetAttribute(IntegerDOM,"value");
if(value_cstr){
long value = reader.ContentToInt( value_cstr );
setValue(value);
}
}
}
Property *PropertyInteger::Copy() const
{
PropertyInteger *p= new PropertyInteger();
@@ -242,6 +261,18 @@ void PropertyPath::Restore(Base::XMLReader &reader)
setValue(reader.getAttribute("value"));
}
void PropertyPath::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
auto PathDOM = reader.FindElement(ContainerDOM,"Path");
if(PathDOM){
// get the value of my Attribute
const char* value_cstr = reader.GetAttribute(PathDOM,"value");
if(value_cstr){
setValue(value_cstr);
}
}
}
Property *PropertyPath::Copy() const
{
PropertyPath *p= new PropertyPath();
@@ -432,6 +463,54 @@ void PropertyEnumeration::Restore(Base::XMLReader &reader)
hasSetValue();
}
void PropertyEnumeration::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
auto IntegerDOM = reader.FindElement(ContainerDOM,"Integer");
if(IntegerDOM){
// get the value of my Attribute
const char* value_cstr = reader.GetAttribute(IntegerDOM,"value");
if(value_cstr){
long val = reader.ContentToInt( value_cstr );
aboutToSetValue();
const char* CustomEnum_cstr = reader.GetAttribute(IntegerDOM,"CustomEnum");
if(CustomEnum_cstr){
auto CustomEnumListDOM = reader.FindElement(IntegerDOM,"CustomEnumList");
if(CustomEnumListDOM){
const char* count_cstr = reader.GetAttribute(IntegerDOM,"count");
if(count_cstr){
long count = reader.ContentToInt( count_cstr );
std::vector<std::string> values(count);
if(count >= 1){
auto prev_EnumDOM = reader.FindElement(CustomEnumListDOM,"Enum");
const char* enum_value_cstr = reader.GetAttribute(prev_EnumDOM,"value");
values[0] = enum_value_cstr;
for(int i = 1; i < count; i++) {
auto EnumDOM_i = reader.FindNextElement(prev_EnumDOM,"Enum");
const char* _enum_value_cstr = reader.GetAttribute(EnumDOM_i,"value");
values[i] = _enum_value_cstr;
prev_EnumDOM = EnumDOM_i;
}
}
_enum.setEnums(values);
}
}
}
if (val < 0) {
// If the enum is empty at this stage do not print a warning
if (_enum.hasEnums())
Base::Console().Warning("Enumeration index %d is out of range, ignore it\n", val);
val = getValue();
}
_enum.setValue(val);
hasSetValue();
}
}
}
PyObject * PropertyEnumeration::getPyObject()
{
if (!_enum.isValid()) {
@@ -782,6 +861,35 @@ void PropertyIntegerList::Restore(Base::XMLReader &reader)
setValues(values);
}
void PropertyIntegerList::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
auto IntegerListDOM = reader.FindElement(ContainerDOM,"IntegerList");
if(IntegerListDOM){
// get the value of my Attribute
const char* count_cstr = reader.GetAttribute(IntegerListDOM,"count");
long count = reader.ContentToInt( count_cstr );
std::vector<long> values(count);
if(count >= 1){
auto prev_I_DOM = reader.FindElement(IntegerListDOM,"I");
const char* v_cstr = reader.GetAttribute(prev_I_DOM,"v");
long v = reader.ContentToInt( v_cstr );
values[0] = v;
for(int i = 1; i < count; i++) {
auto I_DOM_i = reader.FindNextElement(prev_I_DOM,"I");
const char* _v_cstr = reader.GetAttribute(I_DOM_i,"v");
long v = reader.ContentToInt( _v_cstr );
values[i] = v;
prev_I_DOM = I_DOM_i;
}
}
//assignment
setValues(values);
}
}
Property *PropertyIntegerList::Copy() const
{
PropertyIntegerList *p= new PropertyIntegerList();
@@ -902,6 +1010,35 @@ void PropertyIntegerSet::Restore(Base::XMLReader &reader)
setValues(values);
}
void PropertyIntegerSet::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
auto IntegerSetDOM = reader.FindElement(ContainerDOM,"IntegerSet");
if(IntegerSetDOM){
// get the value of my Attribute
const char* count_cstr = reader.GetAttribute(IntegerSetDOM,"count");
long count = reader.ContentToInt( count_cstr );
std::set<long> values;
if(count >= 1){
auto prev_I_DOM = reader.FindElement(IntegerSetDOM,"I");
const char* v_cstr = reader.GetAttribute(prev_I_DOM,"v");
long v = reader.ContentToInt( v_cstr );
values.insert( v );
for(int i = 1; i < count; i++) {
auto I_DOM_i = reader.FindNextElement(prev_I_DOM,"I");
const char* _v_cstr = reader.GetAttribute(I_DOM_i,"v");
long v = reader.ContentToInt( _v_cstr );
values.insert( v );
prev_I_DOM = I_DOM_i;
}
}
//assignment
setValues(values);
}
}
Property *PropertyIntegerSet::Copy() const
{
PropertyIntegerSet *p= new PropertyIntegerSet();
@@ -993,6 +1130,21 @@ void PropertyFloat::Restore(Base::XMLReader &reader)
setValue(reader.getAttributeAsFloat("value"));
}
void PropertyFloat::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
auto FloatDOM = reader.FindElement(ContainerDOM,"Float");
if(FloatDOM){
// get the value of my Attribute
const char* value_cstr = reader.GetAttribute(FloatDOM,"value");
if(value_cstr){
double value = reader.ContentToFloat( value_cstr );
setValue(value);
}
}
}
Property *PropertyFloat::Copy() const
{
PropertyFloat *p= new PropertyFloat();
@@ -1242,6 +1394,24 @@ void PropertyFloatList::Restore(Base::XMLReader &reader)
}
}
void PropertyFloatList::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
//TODO for this its needed to implement addFile() into Reader.cpp, and ReadFiles() since its not possible to have an XMLReader object at this point, because it gives error to use both methods(XMLReader progressive reading and DocumentReader reading) probably because there is something wrong with the zipios implementation, it looks like its locking file or in some way makes the file structure invalid to be readed by xerces by both methods.
//worked around reimplementing ReadFiles in DocumentReader.cpp:
auto FloatListDOM = reader.FindElement(ContainerDOM,"FloatList");
if(FloatListDOM){
// get the value of my Attribute
const char* file_cstr = reader.GetAttribute(FloatListDOM,"file");
if(file_cstr){
string file ( file_cstr );
if (!file.empty()) {
// initiate a file read
reader.addFile(file.c_str(),this);
}
}
}
}
void PropertyFloatList::SaveDocFile (Base::Writer &writer) const
{
Base::OutputStream str(writer.Stream());
@@ -1502,6 +1672,31 @@ void PropertyString::Restore(Base::XMLReader &reader)
setValue(reader.getAttribute("value"));
}
void PropertyString::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
auto StringDOM = reader.FindElement(ContainerDOM,"String");
const char* value_cstr = reader.GetAttribute(StringDOM,"value");
auto obj = dynamic_cast<DocumentObject*>(getContainer());
if(obj && &obj->Label==this) {
const char* restore_cstr = reader.GetAttribute(StringDOM,"restore");
if(restore_cstr) {
int restore = reader.ContentToInt( restore_cstr );
if(restore == 1) {
aboutToSetValue();
_cValue = value_cstr;
hasSetValue();
return;
}
return;
}
}
setValue(value_cstr);
}
Property *PropertyString::Copy() const
{
PropertyString *p= new PropertyString();
@@ -1634,6 +1829,18 @@ void PropertyUUID::Restore(Base::XMLReader &reader)
setValue(reader.getAttribute("value"));
}
void PropertyUUID::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
auto UuidDOM = reader.FindElement(ContainerDOM,"Uuid");
if(UuidDOM){
// get the value of my Attribute
const char* value_cstr = reader.GetAttribute(UuidDOM,"value");
if(value_cstr){
setValue(value_cstr);
}
}
}
Property *PropertyUUID::Copy() const
{
PropertyUUID *p= new PropertyUUID();
@@ -1755,6 +1962,32 @@ void PropertyStringList::Restore(Base::XMLReader &reader)
setValues(values);
}
void PropertyStringList::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
auto StringListDOM = reader.FindElement(ContainerDOM,"StringList");
if(StringListDOM){
// get the value of my Attribute
const char* count_cstr = reader.GetAttribute(StringListDOM,"count");
long count = reader.ContentToInt( count_cstr );
std::vector<std::string> values(count);
if(count >= 1){
auto prev_StringDOM = reader.FindElement(StringListDOM,"String");
const char* value_cstr = reader.GetAttribute(prev_StringDOM,"value");
values[0] = value_cstr;
for(int i = 1; i < count; i++) {
auto StringDOM_i = reader.FindNextElement(prev_StringDOM,"String");
const char* _value_cstr = reader.GetAttribute(StringDOM_i,"value");
values[i] = _value_cstr;
prev_StringDOM = StringDOM_i;
}
}
// assignment
setValues(values);
}
}
Property *PropertyStringList::Copy() const
{
PropertyStringList *p= new PropertyStringList();
@@ -1919,6 +2152,32 @@ void PropertyMap::Restore(Base::XMLReader &reader)
setValues(values);
}
void PropertyMap::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
auto MapDOM = reader.FindElement(ContainerDOM,"Map");
if(MapDOM){
// get the value of my Attribute
const char* count_cstr = reader.GetAttribute(MapDOM,"count");
int count = reader.ContentToInt( count_cstr );
std::map<std::string,std::string> values;
auto prev_ItemDOM = reader.FindElement(MapDOM,"Item");
const char* key_cstr = reader.GetAttribute(prev_ItemDOM,"key");
const char* value_cstr = reader.GetAttribute(prev_ItemDOM,"value");
values[key_cstr] = value_cstr;
for(int i = 1; i < count; i++) {
auto ItemDOM_i = reader.FindNextElement(prev_ItemDOM,"Item");
const char* key_cstr = reader.GetAttribute(ItemDOM_i,"key");
const char* value_cstr = reader.GetAttribute(ItemDOM_i,"value");
values[key_cstr] = value_cstr;
prev_ItemDOM = ItemDOM_i;
}
// assignment
setValues(values);
}
}
Property *PropertyMap::Copy() const
{
PropertyMap *p= new PropertyMap();
@@ -2004,6 +2263,15 @@ void PropertyBool::Restore(Base::XMLReader &reader)
(b == "true") ? setValue(true) : setValue(false);
}
void PropertyBool::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
auto BoolDOM = reader.FindElement(ContainerDOM,"Bool");
if(BoolDOM){
// get the value of my Attribute
string b = reader.GetAttribute(BoolDOM,"value");
(b == "true") ? setValue(true) : setValue(false);
}
}
Property *PropertyBool::Copy() const
{
@@ -2122,6 +2390,18 @@ void PropertyBoolList::Restore(Base::XMLReader &reader)
setValues(bitset);
}
void PropertyBoolList::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
// read my Element
auto BoolListDOM = reader.FindElement(ContainerDOM,"BoolList");
if(BoolListDOM){
// get the value of my Attribute
string str = reader.GetAttribute(BoolListDOM,"value");
boost::dynamic_bitset<> bitset(str);
setValues(bitset);
}
}
Property *PropertyBoolList::Copy() const
{
PropertyBoolList *p= new PropertyBoolList();
@@ -2275,6 +2555,17 @@ void PropertyColor::Restore(Base::XMLReader &reader)
setValue(rgba);
}
void PropertyColor::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
// read my Element
auto PropertyColorDOM = reader.FindElement(ContainerDOM,"PropertyColor");
if(PropertyColorDOM){
const char* val_cstr = reader.GetAttribute(PropertyColorDOM,"value");
unsigned long rgba = reader.ContentToUnsigned(val_cstr);
setValue(rgba);
}
}
Property *PropertyColor::Copy() const
{
PropertyColor *p= new PropertyColor();
@@ -2354,6 +2645,22 @@ void PropertyColorList::Restore(Base::XMLReader &reader)
}
}
void PropertyColorList::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
auto ColorListDOM = reader.FindElement(ContainerDOM,"ColorList");
if(ColorListDOM){
// get the value of my Attribute
const char* file_cstr = reader.GetAttribute(ColorListDOM,"file");
if(file_cstr){
std::string file (file_cstr);
if (!file.empty()) {
// initiate a file read
reader.addFile(file.c_str(),this);
}
}
}
}
void PropertyColorList::SaveDocFile (Base::Writer &writer) const
{
Base::OutputStream str(writer.Stream());
@@ -2504,6 +2811,32 @@ void PropertyMaterial::Restore(Base::XMLReader &reader)
hasSetValue();
}
void PropertyMaterial::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
// read my Element
auto PropertyMaterialDOM = reader.FindElement(ContainerDOM,"PropertyMaterial");
if(PropertyMaterialDOM){
// get the value of my Attribute
aboutToSetValue();
const char* ambientColor_cstr = reader.GetAttribute(PropertyMaterialDOM,"ambientColor");
const char* diffuseColor_cstr = reader.GetAttribute(PropertyMaterialDOM,"diffuseColor");
const char* specularColor_cstr = reader.GetAttribute(PropertyMaterialDOM,"specularColor");
const char* emissiveColor_cstr = reader.GetAttribute(PropertyMaterialDOM,"emissiveColor");
const char* shininess_cstr = reader.GetAttribute(PropertyMaterialDOM,"shininess");
const char* transparency_cstr = reader.GetAttribute(PropertyMaterialDOM,"transparency");
_cMat.ambientColor.setPackedValue(reader.ContentToUnsigned(ambientColor_cstr));
_cMat.diffuseColor.setPackedValue(reader.ContentToUnsigned(diffuseColor_cstr));
_cMat.specularColor.setPackedValue(reader.ContentToUnsigned(specularColor_cstr));
_cMat.emissiveColor.setPackedValue(reader.ContentToUnsigned(emissiveColor_cstr));
_cMat.shininess = (float)reader.ContentToFloat(shininess_cstr);
_cMat.transparency = (float)reader.ContentToFloat(transparency_cstr);
hasSetValue();
}
}
const char* PropertyMaterial::getEditorName() const
{
if(testStatus(MaterialEdit))
@@ -2583,6 +2916,22 @@ void PropertyMaterialList::Restore(Base::XMLReader &reader)
}
}
void PropertyMaterialList::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
auto MaterialListDOM = reader.FindElement(ContainerDOM,"MaterialList");
if(MaterialListDOM){
// get the value of my Attribute
const char* file_cstr = reader.GetAttribute(MaterialListDOM,"file");
if(file_cstr){
std::string file (file_cstr);
if (!file.empty()) {
// initiate a file read
reader.addFile(file.c_str(),this);
}
}
}
}
void PropertyMaterialList::SaveDocFile(Base::Writer &writer) const
{
Base::OutputStream str(writer.Stream());
@@ -2679,6 +3028,14 @@ void PropertyPersistentObject::Restore(Base::XMLReader &reader){
reader.readEndElement(ELEMENT_PERSISTENT_OBJ);
}
void PropertyPersistentObject::Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM)
{
inherited::Restore(reader,ContainerDOM);
auto element_persistent_obj_DOM = reader.FindElement(ELEMENT_PERSISTENT_OBJ);
if(_pObject)
_pObject->Restore(reader,element_persistent_obj_DOM);
}
Property *PropertyPersistentObject::Copy() const{
auto *p= new PropertyPersistentObject();
p->_cValue = _cValue;

24
src/App/PropertyStandard.h
View File

@@ -36,6 +36,12 @@
#include "Enumeration.h"
#include "Material.h"
#include <xercesc/util/XercesDefs.hpp>
XERCES_CPP_NAMESPACE_BEGIN
class DOMElement;
XERCES_CPP_NAMESPACE_END
namespace Base {
class Writer;
@@ -70,6 +76,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property *Copy() const override;
void Paste(const Property &from) override;
@@ -121,6 +128,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property *Copy() const override;
void Paste(const Property &from) override;
@@ -220,6 +228,7 @@ public:
void Save(Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property * Copy() const override;
void Paste(const Property &from) override;
@@ -358,6 +367,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property *Copy() const override;
void Paste(const Property &from) override;
@@ -403,6 +413,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property *Copy() const override;
void Paste(const Property &from) override;
@@ -462,6 +473,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property *Copy() const override;
void Paste(const Property &from) override;
@@ -515,6 +527,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property *Copy() const override;
void Paste(const Property &from) override;
@@ -658,6 +671,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
void SaveDocFile (Base::Writer &writer) const override;
void RestoreDocFile(Base::Reader &reader) override;
@@ -705,6 +719,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property *Copy() const override;
void Paste(const Property &from) override;
@@ -758,6 +773,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property *Copy() const override;
void Paste(const Property &from) override;
@@ -824,6 +840,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property *Copy() const override;
void Paste(const Property &from) override;
@@ -865,6 +882,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property *Copy() const override;
void Paste(const Property &from) override;
@@ -902,6 +920,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property *Copy() const override;
void Paste(const Property &from) override;
@@ -949,6 +968,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property *Copy() const override;
void Paste(const Property &from) override;
@@ -988,6 +1008,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
void SaveDocFile (Base::Writer &writer) const override;
void RestoreDocFile(Base::Reader &reader) override;
@@ -1040,6 +1061,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
const char* getEditorName() const override;
@@ -1083,6 +1105,7 @@ public:
void Save(Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
void SaveDocFile(Base::Writer &writer) const override;
void RestoreDocFile(Base::Reader &reader) override;
@@ -1112,6 +1135,7 @@ public:
void Save (Base::Writer &writer) const override;
void Restore(Base::XMLReader &reader) override;
void Restore(Base::DocumentReader &reader,XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ContainerDOM) override;
Property *Copy() const override;
void Paste(const Property &from) override;