PropertyContainer& Mesh:: createPropertyContainer()
{
PropertyContainer* newPropertyContainer = new PropertyContainer();
newPropertyContainer->addParent(*this);
_propertyContainers.push_back(newPropertyContainer);
return *newPropertyContainer;
}
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");
}
}
//-*****************************************************************************
Reader::Request
Reader::component( const std::string &name,
const std::string &ininterp,
const ComponentInfo &info )
{
std::string interp = ininterp;
if ( fileHeader().version < 3 ) { interp = GTO_INTERPRET_DEFAULT; }
if ( m_objects == NULL )
{
GTC_THROW( "Reader reading without objects" );
}
PropertyContainer *g =
reinterpret_cast<PropertyContainer*>( info.object->objectData );
Component *c = g->component( name );
if ( !c )
{
// adds it too.
c = g->createComponent( name, info.flags & Gto::Matrix );
}
return Request( true, c );
}
std::string PropertyFileIncluded::getDocTransientPath(void) const
{
PropertyContainer *co = getContainer();
if (co->isDerivedFrom(DocumentObject::getClassTypeId()))
return dynamic_cast<DocumentObject*>(co)->getDocument()->TransientDir.getValue();
return std::string();
}
std::string PropertyFileIncluded::getDocTransientPath(void) const
{
std::string path;
PropertyContainer *co = getContainer();
if (co->isDerivedFrom(DocumentObject::getClassTypeId())) {
path = static_cast<DocumentObject*>(co)->getDocument()->TransientDir.getValue();
std::replace(path.begin(), path.end(), '\\', '/');
}
return path;
}
Expression * VariableExpression::eval() const
{
const Property * prop = getProperty();
PropertyContainer * parent = prop->getContainer();
if (!parent->isDerivedFrom(App::DocumentObject::getClassTypeId()))
throw ExpressionError("Property must belong to a document object.");
boost::any value = prop->getPathValue(var);
if (value.type() == typeid(Quantity)) {
Quantity qvalue = boost::any_cast<Quantity>(value);
return new NumberExpression(owner, qvalue);
}
else if (value.type() == typeid(double)) {
double dvalue = boost::any_cast<double>(value);
return new NumberExpression(owner, dvalue);
}
else if (value.type() == typeid(float)) {
double fvalue = boost::any_cast<float>(value);
return new NumberExpression(owner, fvalue);
}
else if (value.type() == typeid(int)) {
int ivalue = boost::any_cast<int>(value);
return new NumberExpression(owner, ivalue);
}
else if (value.type() == typeid(std::string)) {
std::string svalue = boost::any_cast<std::string>(value);
return new StringExpression(owner, svalue);
}
else if (value.type() == typeid(char*)) {
char* svalue = boost::any_cast<char*>(value);
return new StringExpression(owner, svalue);
}
else if (value.type() == typeid(const char*)) {
const char* svalue = boost::any_cast<const char*>(value);
return new StringExpression(owner, svalue);
}
throw ExpressionError("Property is of invalid type.");
}
void PropertyPythonObject::saveObject(Base::Writer &writer) const
{
Base::PyGILStateLocker lock;
try {
PropertyContainer* parent = this->getContainer();
if (parent->isDerivedFrom(Base::Type::fromName("App::DocumentObject"))) {
if (this->object.hasAttr("__object__")) {
writer.Stream() << " object=\"yes\"";
}
}
if (parent->isDerivedFrom(Base::Type::fromName("Gui::ViewProvider"))) {
if (this->object.hasAttr("__vobject__")) {
writer.Stream() << " vobject=\"yes\"";
}
}
}
catch (Py::Exception& e) {
e.clear();
}
}
//-*****************************************************************************
Reader::Request
Reader::object( const std::string &name,
const std::string &prot,
unsigned int protVersion,
const ObjectInfo &info )
{
if ( m_objects == NULL )
{
GTC_THROW( "Reader reading without objects" );
}
PropertyContainer *g = NULL;
Protocol protocol( prot, protVersion );
bool found = false;
if ( m_useExisting )
{
for ( int i = 0; i < m_objects->size(); ++i )
{
PropertyContainer *pc = (*m_objects)[i];
if ( pc->name() == name &&
pc->protocol() == protocol )
{
found = true;
g = pc;
}
}
}
if ( !g )
{
g = newContainer( protocol );
g->setName( name );
g->setProtocol( protocol );
}
if ( !found ) { m_objects->push_back( g ); }
return Request( true, g );
}
