kindred/create
1
1
Fork 0
Code Issues 53 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity
Files
bfb72a6925d29de0b3321ba568dea1279d79d75b
create/src/App/DocumentObject.cpp
PhoneDroid 8abd25c999 [ App ]: Update SPDX License Identifiers
2025-12-25 11:55:37 -06:00

1672 lines
53 KiB
C++
Raw Blame History

// SPDX-License-Identifier: LGPL-2.1-or-later
/***************************************************************************
* Copyright (c) 2011 Jürgen Riegel <juergen.riegel@web.de> *
* Copyright (c) 2011 Werner Mayer <wmayer[at]users.sourceforge.net> *
* *
* This file is part of the FreeCAD CAx development system. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Library General Public *
* License as published by the Free Software Foundation; either *
* version 2 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Library General Public License for more details. *
* *
* You should have received a copy of the GNU Library General Public *
* License along with this library; see the file COPYING.LIB. If not, *
* write to the Free Software Foundation, Inc., 59 Temple Place, *
* Suite 330, Boston, MA 02111-1307, USA *
* *
***************************************************************************/
#include <stack>
#include <memory>
#include <map>
#include <set>
#include <vector>
#include <string>
#include <Base/Console.h>
#include <Base/Matrix.h>
#include <Base/Placement.h>
#include <Base/Tools.h>
#include <Base/Writer.h>
#include "Expression.h"
#include "Application.h"
#include "ElementNamingUtils.h"
#include "Document.h"
#include "DocumentObject.h"
#include "DocumentObjectPy.h"
#include "DocumentObjectExtension.h"
#include "DocumentObjectGroup.h"
#include "GeoFeatureGroupExtension.h"
#include "Link.h"
#include "ObjectIdentifier.h"
#include "PropertyExpressionEngine.h"
#include "PropertyLinks.h"
FC_LOG_LEVEL_INIT("App", true, true)
using namespace App;
PROPERTY_SOURCE(App::DocumentObject, App::TransactionalObject)
DocumentObjectExecReturn* DocumentObject::StdReturn = nullptr;
//===========================================================================
// DocumentObject
//===========================================================================
DocumentObject::DocumentObject()
: ExpressionEngine()
{
// define Label of type 'Output' to avoid being marked as touched after relabeling
ADD_PROPERTY_TYPE(Label, ("Unnamed"), "Base", Prop_Output, "User name of the object (UTF8)");
ADD_PROPERTY_TYPE(Label2, (""), "Base", Prop_Hidden, "User description of the object (UTF8)");
Label2.setStatus(App::Property::Output, true);
ADD_PROPERTY_TYPE(ExpressionEngine, (), "Base", Prop_Hidden, "Property expressions");
ADD_PROPERTY(Visibility, (true));
// default set Visibility status to hidden and output (no touch) for
// compatibitily reason. We use setStatus instead of PropertyType to
// allow user to change its status later
Visibility.setStatus(Property::Output, true);
Visibility.setStatus(Property::Hidden, true);
Visibility.setStatus(Property::NoModify, true);
}
DocumentObject::~DocumentObject()
{
if (!PythonObject.is(Py::_None())) {
Base::PyGILStateLocker lock;
// Remark: The API of Py::Object has been changed to set whether the wrapper owns the passed
// Python object or not. In the constructor we forced the wrapper to own the object so we
// need not to dec'ref the Python object any more. But we must still invalidate the Python
// object because it need not to be destructed right now because the interpreter can own
// several references to it.
Base::PyObjectBase* obj = static_cast<Base::PyObjectBase*>(PythonObject.ptr());
// Call before decrementing the reference counter, otherwise a heap error can occur
obj->setInvalid();
}
}
void DocumentObject::printInvalidLinks() const
{
try {
// Get objects that have invalid link scope, and print their names.
// Truncate the invalid object list name strings for readability, if they happen to be very
// long.
std::vector<App::DocumentObject*> invalid_linkobjs;
std::string objnames, scopenames;
GeoFeatureGroupExtension::getInvalidLinkObjects(this, invalid_linkobjs);
for (auto& obj : invalid_linkobjs) {
objnames += obj->getNameInDocument();
objnames += " ";
for (auto& scope : obj->getParents()) {
if (scopenames.length() > 80) {
scopenames += "... ";
break;
}
scopenames += scope.first->getNameInDocument();
scopenames += " ";
}
if (objnames.length() > 80) {
objnames += "... ";
break;
}
}
if (objnames.empty()) {
objnames = "N/A";
}
else {
objnames.pop_back();
}
if (scopenames.empty()) {
scopenames = "N/A";
}
else {
scopenames.pop_back();
}
Base::Console().warning("%s: Link(s) to object(s) '%s' go out of the allowed scope '%s'. "
"Instead, the linked object(s) reside within '%s'.\n",
getTypeId().getName(),
objnames.c_str(),
getNameInDocument(),
scopenames.c_str());
}
catch (const Base::Exception& e) {
e.reportException();
}
}
App::DocumentObjectExecReturn* DocumentObject::recompute()
{
// check if the links are valid before making the recompute
if (!GeoFeatureGroupExtension::areLinksValid(this)) {
printInvalidLinks();
}
// set/unset the execution bit
Base::ObjectStatusLocker<ObjectStatus, DocumentObject> exe(App::Recompute, this);
// mark the object to recompute its extensions
this->setStatus(App::RecomputeExtension, true);
auto ret = this->execute();
if (ret == StdReturn) {
// most feature classes don't call the execute() method of its base class
// so execute the extensions now
if (this->testStatus(App::RecomputeExtension)) {
ret = executeExtensions();
}
}
return ret;
}
DocumentObjectExecReturn* DocumentObject::execute()
{
return executeExtensions();
}
App::DocumentObjectExecReturn* DocumentObject::executeExtensions()
{
// execute extensions but stop on error
this->setStatus(App::RecomputeExtension, false); // reset the flag
auto vector = getExtensionsDerivedFromType<App::DocumentObjectExtension>();
for (auto ext : vector) {
auto ret = ext->extensionExecute();
if (ret != StdReturn) {
return ret;
}
}
return StdReturn;
}
bool DocumentObject::recomputeFeature(bool recursive)
{
Document* doc = this->getDocument();
if (doc) {
return doc->recomputeFeature(this, recursive);
}
return isValid();
}
/**
* @brief Set this document object touched.
* Touching a document object does not mean to recompute it, it only means that
* other document objects that link it (i.e. its InList) will be recomputed.
* If it should be forced to recompute a document object then use
* \ref enforceRecompute() instead.
*/
void DocumentObject::touch(bool noRecompute)
{
if (!noRecompute) {
StatusBits.set(ObjectStatus::Enforce);
}
StatusBits.set(ObjectStatus::Touch);
if (_pDoc) {
_pDoc->signalTouchedObject(*this);
}
}
/**
* @brief Set this document object freezed.
* A freezed document object does not recompute ever.
*/
void DocumentObject::freeze()
{
StatusBits.set(ObjectStatus::Freeze);
// store read-only property names
this->readOnlyProperties.clear();
std::vector<std::pair<const char*, Property*>> list;
static_cast<App::PropertyContainer*>(this)->getPropertyNamedList(list);
for (auto pair: list){
if (pair.second->isReadOnly()){
this->readOnlyProperties.push_back(pair.first);
} else {
pair.second->setReadOnly(true);
}
}
// use the signalTouchedObject to refresh the Gui
if (_pDoc) {
_pDoc->signalTouchedObject(*this);
}
}
/**
* @brief Set this document object unfreezed.
* A freezed document object does not recompute ever.
*/
void DocumentObject::unfreeze(bool noRecompute)
{
StatusBits.reset(ObjectStatus::Freeze);
// reset read-only property status
std::vector<std::pair<const char*, Property*>> list;
static_cast<App::PropertyContainer*>(this)->getPropertyNamedList(list);
for (auto pair: list){
if (! std::count(readOnlyProperties.begin(), readOnlyProperties.end(), pair.first)){
pair.second->setReadOnly(false);
}
}
touch(noRecompute);
}
/**
* @brief Check whether the document object is touched or not.
* @return true if document object is touched, false if not.
*/
bool DocumentObject::isTouched() const
{
return ExpressionEngine.isTouched() || StatusBits.test(ObjectStatus::Touch);
}
/**
* @brief Enforces this document object to be recomputed.
* This can be useful to recompute the feature without
* having to change one of its input properties.
*/
void DocumentObject::enforceRecompute()
{
touch(false);
}
/**
* @brief Check whether the document object must be recomputed or not.
* This means that the 'Enforce' flag is set or that \ref mustExecute()
* returns a value > 0.
* @return true if document object must be recomputed, false if not.
*/
bool DocumentObject::mustRecompute() const
{
if (StatusBits.test(ObjectStatus::Freeze)) {
return false;
}
if (StatusBits.test(ObjectStatus::Enforce)) {
return true;
}
return mustExecute() > 0;
}
short DocumentObject::mustExecute() const
{
if (ExpressionEngine.isTouched()) {
return 1;
}
// ask all extensions
auto vector = getExtensionsDerivedFromType<App::DocumentObjectExtension>();
for (auto ext : vector) {
if (ext->extensionMustExecute()) {
return 1;
}
}
return 0;
}
const char* DocumentObject::getStatusString() const
{
if (isError()) {
const char* text = getDocument()->getErrorDescription(this);
return text ? text : "Error";
}
else if (isFreezed()){
return "Freezed";
}
else if (isTouched()) {
return "Touched";
}
else {
return "Valid";
}
}
std::string DocumentObject::getFullName() const
{
if (!getDocument() || !isAttachedToDocument()) {
return "?";
}
std::string name(getDocument()->getName());
name += '#';
name += *pcNameInDocument;
return name;
}
std::string DocumentObject::getFullLabel() const
{
if (!getDocument()) {
return "?";
}
auto name = getDocument()->Label.getStrValue();
name += "#";
name += Label.getStrValue();
return name;
}
const char* DocumentObject::getDagKey() const
{
if (!pcNameInDocument) {
return nullptr;
}
return pcNameInDocument->c_str();
}
const char* DocumentObject::getNameInDocument() const
{
// Note: It can happen that we query the internal name of an object even if it is not
// part of a document (anymore). This is the case e.g. if we have a reference in Python
// to an object that has been removed from the document. In this case we should rather
// return 0.
// assert(pcNameInDocument);
if (!pcNameInDocument) {
return nullptr;
}
return pcNameInDocument->c_str();
}
int DocumentObject::isExporting() const
{
if (!getDocument() || !isAttachedToDocument()) {
return 0;
}
return getDocument()->isExporting(this);
}
std::string DocumentObject::getExportName(bool forced) const
{
if (!isAttachedToDocument()) {
return {};
}
if (!forced && !isExporting()) {
return *pcNameInDocument;
}
// '@' is an invalid character for an internal name, which ensures the
// following returned name will be unique in any document. Saving external
// object like that shall only happens in Document::exportObjects(). We
// shall strip out this '@' and the following document name during restoring.
return *pcNameInDocument + '@' + getDocument()->getName();
}
bool DocumentObject::isAttachedToDocument() const
{
return (pcNameInDocument != nullptr);
}
const char* DocumentObject::detachFromDocument()
{
const std::string* name = pcNameInDocument;
pcNameInDocument = nullptr;
return name ? name->c_str() : nullptr;
}
const std::vector<DocumentObject*>& DocumentObject::getOutList() const
{
if (!_outListCached) {
_outList.clear();
getOutList(0, _outList);
_outListCached = true;
}
return _outList;
}
std::vector<DocumentObject*> DocumentObject::getOutList(int options) const
{
std::vector<DocumentObject*> res;
getOutList(options, res);
return res;
}
void DocumentObject::getOutList(int options, std::vector<DocumentObject*>& res) const
{
if (_outListCached && !options) {
res.insert(res.end(), _outList.begin(), _outList.end());
return;
}
std::vector<Property*> props;
getPropertyList(props);
bool noHidden = !!(options & OutListNoHidden);
std::size_t size = res.size();
for (auto prop : props) {
auto link = freecad_cast<PropertyLinkBase*>(prop);
if (link) {
link->getLinks(res, noHidden);
}
}
if (!(options & OutListNoExpression)) {
ExpressionEngine.getLinks(res);
}
if (options & OutListNoXLinked) {
for (auto it = res.begin() + size; it != res.end();) {
auto obj = *it;
if (obj && obj->getDocument() != getDocument()) {
it = res.erase(it);
}
else {
++it;
}
}
}
}
std::vector<App::DocumentObject*> DocumentObject::getOutListOfProperty(App::Property* prop) const
{
std::vector<DocumentObject*> ret;
if (!prop || prop->getContainer() != this) {
return ret;
}
auto link = freecad_cast<PropertyLinkBase*>(prop);
if (link) {
link->getLinks(ret);
}
return ret;
}
const std::vector<App::DocumentObject*>& DocumentObject::getInList() const
{
return _inList;
}
// The original algorithm is highly inefficient in some special case.
// Considering an object is linked by every other objects. After excluding this
// object, there is another object linked by every other of the remaining
// objects, and so on. The vector 'result' above will be of magnitude n^2.
// Even if we replace the vector with a set, we still need to visit that amount
// of objects. And this may not be the worst case. getInListEx() has no such
// problem.
std::vector<App::DocumentObject*> DocumentObject::getInListRecursive() const
{
std::set<App::DocumentObject*> inSet;
std::vector<App::DocumentObject*> res;
getInListEx(inSet, true, &res);
return res;
}
// More efficient algorithm to find the recursive inList of an object,
// including possible external parents. One shortcoming of this algorithm is
// it does not detect cyclic reference, althgouth it won't crash either.
void DocumentObject::getInListEx(std::set<App::DocumentObject*>& inSet,
bool recursive,
std::vector<App::DocumentObject*>* inList) const
{
if (!recursive) {
inSet.insert(_inList.begin(), _inList.end());
if (inList) {
*inList = _inList;
}
return;
}
std::stack<DocumentObject*> pendings;
pendings.push(const_cast<DocumentObject*>(this));
while (!pendings.empty()) {
auto obj = pendings.top();
pendings.pop();
for (auto o : obj->getInList()) {
if (o && o->isAttachedToDocument() && inSet.insert(o).second) {
pendings.push(o);
if (inList) {
inList->push_back(o);
}
}
}
}
}
std::set<App::DocumentObject*> DocumentObject::getInListEx(bool recursive) const
{
std::set<App::DocumentObject*> ret;
getInListEx(ret, recursive);
return ret;
}
void _getOutListRecursive(std::set<DocumentObject*>& objSet,
const DocumentObject* obj,
const DocumentObject* checkObj,
int depth)
{
for (const auto objIt : obj->getOutList()) {
// if the check object is in the recursive inList we have a cycle!
if (objIt == checkObj || depth <= 0) {
throw Base::BadGraphError(
"DocumentObject::getOutListRecursive(): cyclic dependency detected!");
}
// if the element was already in the set then there is no need to process it again
auto pair = objSet.insert(objIt);
if (pair.second) {
_getOutListRecursive(objSet, objIt, checkObj, depth - 1);
}
}
}
std::vector<App::DocumentObject*> DocumentObject::getOutListRecursive() const
{
// number of objects in document is a good estimate in result size
int maxDepth = GetApplication().checkLinkDepth(0);
std::set<App::DocumentObject*> result;
// using a recursive helper to collect all OutLists
_getOutListRecursive(result, this, this, maxDepth);
std::vector<App::DocumentObject*> array;
array.insert(array.begin(), result.begin(), result.end());
return array;
}
// helper for isInInListRecursive()
bool _isInInListRecursive(const DocumentObject* act, const DocumentObject* checkObj, int depth)
{
for (auto obj : act->getInList()) {
if (obj == checkObj) {
return true;
}
// if we reach the depth limit we have a cycle!
if (depth <= 0) {
throw Base::BadGraphError(
"DocumentObject::isInInListRecursive(): cyclic dependency detected!");
}
if (_isInInListRecursive(obj, checkObj, depth - 1)) {
return true;
}
}
return false;
}
bool DocumentObject::isInInListRecursive(DocumentObject* linkTo) const
{
return this == linkTo || getInListEx(true).contains(linkTo);
}
bool DocumentObject::isInInList(DocumentObject* linkTo) const
{
if (std::ranges::find(_inList, linkTo) != _inList.end()) {
return true;
}
else {
return false;
}
}
// helper for isInOutListRecursive()
bool _isInOutListRecursive(const DocumentObject* act, const DocumentObject* checkObj, int depth)
{
for (auto obj : act->getOutList()) {
if (obj == checkObj) {
return true;
}
// if we reach the depth limit we have a cycle!
if (depth <= 0) {
throw Base::BadGraphError(
"DocumentObject::isInOutListRecursive(): cyclic dependency detected!");
}
if (_isInOutListRecursive(obj, checkObj, depth - 1)) {
return true;
}
}
return false;
}
bool DocumentObject::isInOutListRecursive(DocumentObject* linkTo) const
{
int maxDepth = getDocument()->countObjects() + 2;
return _isInOutListRecursive(this, linkTo, maxDepth);
}
std::vector<std::list<App::DocumentObject*>>
DocumentObject::getPathsByOutList(App::DocumentObject* to) const
{
return _pDoc->getPathsByOutList(this, to);
}
DocumentObjectGroup* DocumentObject::getGroup() const
{
return freecad_cast<DocumentObjectGroup*>(GroupExtension::getGroupOfObject(this));
}
bool DocumentObject::testIfLinkDAGCompatible(DocumentObject* linkTo) const
{
std::vector<App::DocumentObject*> linkTo_in_vector;
linkTo_in_vector.push_back(linkTo);
return this->testIfLinkDAGCompatible(linkTo_in_vector);
}
bool DocumentObject::testIfLinkDAGCompatible(const std::vector<DocumentObject*>& linksTo) const
{
auto inLists = getInListEx(true);
inLists.emplace(const_cast<DocumentObject*>(this));
for (auto obj : linksTo) {
if (inLists.contains(obj)) {
return false;
}
}
return true;
}
bool DocumentObject::testIfLinkDAGCompatible(PropertyLinkSubList& linksTo) const
{
const std::vector<App::DocumentObject*>& linksTo_in_vector = linksTo.getValues();
return this->testIfLinkDAGCompatible(linksTo_in_vector);
}
bool DocumentObject::testIfLinkDAGCompatible(PropertyLinkSub& linkTo) const
{
std::vector<App::DocumentObject*> linkTo_in_vector;
linkTo_in_vector.reserve(1);
linkTo_in_vector.push_back(linkTo.getValue());
return this->testIfLinkDAGCompatible(linkTo_in_vector);
}
void DocumentObject::onLostLinkToObject(DocumentObject*)
{}
App::Document* DocumentObject::getDocument() const
{
return _pDoc;
}
void DocumentObject::setDocument(App::Document* doc)
{
_pDoc = doc;
onSettingDocument();
}
bool DocumentObject::removeDynamicProperty(const char* name)
{
if (!_pDoc || testStatus(ObjectStatus::Destroy)) {
return false;
}
Property* prop = getDynamicPropertyByName(name);
if (!prop || prop->testStatus(App::Property::LockDynamic)) {
return false;
}
if (prop->isDerivedFrom<PropertyLinkBase>()) {
clearOutListCache();
}
_pDoc->addOrRemovePropertyOfObject(this, prop, false);
auto expressions = ExpressionEngine.getExpressions();
std::vector<App::ObjectIdentifier> removeExpr;
for (const auto& it : expressions) {
if (it.first.getProperty() == prop) {
removeExpr.push_back(it.first);
}
}
for (const auto& it : removeExpr) {
ExpressionEngine.setValue(it, std::shared_ptr<Expression>());
}
return TransactionalObject::removeDynamicProperty(name);
}
bool DocumentObject::renameDynamicProperty(Property* prop, const char* name)
{
std::string oldName = prop->getName();
auto expressions = ExpressionEngine.getExpressions();
std::vector<std::shared_ptr<Expression>> expressionsToMove;
std::vector<App::ObjectIdentifier> idsWithExprsToRemove;
for (const auto& [id, expr] : expressions) {
if (id.getProperty() == prop) {
idsWithExprsToRemove.push_back(id);
expressionsToMove.emplace_back(expr->copy());
}
}
for (const auto& it : idsWithExprsToRemove) {
ExpressionEngine.setValue(it, std::shared_ptr<Expression>());
}
bool renamed = TransactionalObject::renameDynamicProperty(prop, name);
if (renamed && _pDoc) {
_pDoc->renamePropertyOfObject(this, prop, oldName.c_str());
}
App::ObjectIdentifier idNewProp(prop->getContainer(), std::string(name));
for (auto& exprToMove : expressionsToMove) {
ExpressionEngine.setValue(idNewProp, exprToMove);
}
return renamed;
}
App::Property* DocumentObject::addDynamicProperty(const char* type,
const char* name,
const char* group,
const char* doc,
short attr,
bool ro,
bool hidden)
{
auto prop = TransactionalObject::addDynamicProperty(type, name, group, doc, attr, ro, hidden);
if (prop && _pDoc) {
_pDoc->addOrRemovePropertyOfObject(this, prop, true);
}
return prop;
}
void DocumentObject::onBeforeChange(const Property* prop)
{
if (isFreezed() && prop != &Visibility) {
return;
}
// Store current name in oldLabel, to be able to easily retrieve old name of document object later
// when renaming expressions.
if (prop == &Label)
oldLabel = Label.getStrValue();
if (_pDoc){
onBeforeChangeProperty(_pDoc, prop);
}
signalBeforeChange(*this, *prop);
}
std::vector<std::pair<Property*, std::unique_ptr<Property>>>
DocumentObject::onProposedLabelChange(std::string& newLabel)
{
// Note that this work can't be done in onBeforeChangeLabel because FeaturePython overrides this
// method and does not initially base-call it.
// We re only called if the new label differs from the old one, and our code to check duplicates
// may not work if this is not the case.
std::string oldLabel = Label.getStrValue();
assert(newLabel != oldLabel);
if (!isAttachedToDocument()) {
return {};
}
App::Document* doc = getDocument();
if (doc->isPerformingTransaction()
|| (doc->testStatus(App::Document::Restoring)
&& !doc->testStatus(App::Document::Importing))) {
return {};
}
static ParameterGrp::handle _hPGrp;
if (!_hPGrp) {
_hPGrp = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/Document");
}
if (doc && !newLabel.empty() && !_hPGrp->GetBool("DuplicateLabels") && !allowDuplicateLabel()
&& doc->containsLabel(newLabel)) {
// The label already exists but settings are such that duplicate labels should not be assigned.
std::string objName = getNameInDocument();
if (!doc->containsLabel(objName) && doc->haveSameBaseName(objName, newLabel)) {
// The object name is not already a Label and the base name of the proposed label
// equals the base name of the object Name, so we use the object Name as the replacement Label.
newLabel = objName;
}
else {
// Otherwise we generate a unique Label using newLabel as a prototype name. In doing so,
// we must also act as if the current value of the property is not an existing Label
// entry.
// We deregister the old label so it does not interfere with making the new label,
// and re-register it after. This is probably a bit less efficient that having a special
// make-unique-label-as-if-this-one-did-not-exist method, but such a method would be a real
// ugly wart.
doc->unregisterLabel(oldLabel);
newLabel = doc->makeUniqueLabel(newLabel);
doc->registerLabel(oldLabel);
}
}
// Despite our efforts to make a unique label, onBeforeLabelChange can change it.
onBeforeChangeLabel(newLabel);
if (oldLabel == newLabel || getDocument()->testStatus(App::Document::Restoring)) {
// Don't update label reference if we are restoring or if the label is unchanged.
// When importing (which also counts as restoring), it is possible the
// new object changes its label. However, we cannot update label
// references here, because object being restored is not based on
// dependency order. It can only be done in afterRestore().
//
// See PropertyLinkBase::restoreLabelReference() for more details.
return {};
}
return PropertyLinkBase::updateLabelReferences(this, newLabel.c_str());
}
void DocumentObject::onEarlyChange(const Property* prop)
{
if (isFreezed() && prop != &Visibility) {
return;
}
if (GetApplication().isClosingAll()) {
return;
}
if (!GetApplication().isRestoring() && !prop->testStatus(Property::PartialTrigger)
&& getDocument() && getDocument()->testStatus(Document::PartialDoc)) {
static App::Document* warnedDoc;
if (warnedDoc != getDocument()) {
warnedDoc = getDocument();
FC_WARN("Changes to partial loaded document will not be saved: " << getFullName() << '.'
<< prop->getName());
}
}
signalEarlyChanged(*this, *prop);
}
/// get called by the container when a Property was changed
void DocumentObject::onChanged(const Property* prop)
{
if (prop == &Label && _pDoc && _pDoc->containsObject(this) && oldLabel != Label.getStrValue()) {
_pDoc->unregisterLabel(oldLabel);
_pDoc->registerLabel(Label.getStrValue());
}
if (isFreezed() && prop != &Visibility) {
return;
}
if (GetApplication().isClosingAll()) {
return;
}
if (!GetApplication().isRestoring() && !prop->testStatus(Property::PartialTrigger)
&& getDocument() && getDocument()->testStatus(Document::PartialDoc)) {
static App::Document* warnedDoc;
if (warnedDoc != getDocument()) {
warnedDoc = getDocument();
FC_WARN("Changes to partial loaded document will not be saved: " << getFullName() << '.'
<< prop->getName());
}
}
// Delay signaling view provider until the document object has handled the
// change
// if (_pDoc)
// _pDoc->onChangedProperty(this,prop);
if (prop == &Label && _pDoc && oldLabel != Label.getStrValue()) {
_pDoc->signalRelabelObject(*this);
}
// set object touched if it is an input property
if (!testStatus(ObjectStatus::NoTouch) && !(prop->getType() & Prop_Output)
&& !prop->testStatus(Property::Output)) {
if (!StatusBits.test(ObjectStatus::Touch)) {
FC_TRACE("touch '" << getFullName() << "' on change of '" << prop->getName() << "'");
StatusBits.set(ObjectStatus::Touch);
}
// must execute on document recompute
if (!(prop->getType() & Prop_NoRecompute)) {
StatusBits.set(ObjectStatus::Enforce);
}
}
// call the parent for appropriate handling
TransactionalObject::onChanged(prop);
// Now signal the view provider
if (_pDoc) {
_pDoc->onChangedProperty(this, prop);
}
signalChanged(*this, *prop);
}
void DocumentObject::clearOutListCache() const
{
_outList.clear();
_outListMap.clear();
_outListCached = false;
}
PyObject* DocumentObject::getPyObject()
{
if (PythonObject.is(Py::_None())) {
// ref counter is set to 1
PythonObject = Py::Object(new DocumentObjectPy(this), true);
}
return Py::new_reference_to(PythonObject);
}
DocumentObject* DocumentObject::getSubObject(const char* subname,
PyObject** pyObj,
Base::Matrix4D* mat,
bool transform,
int depth) const
{
DocumentObject* ret = nullptr;
auto exts = getExtensionsDerivedFromType<App::DocumentObjectExtension>();
for (auto ext : exts) {
if (ext->extensionGetSubObject(ret, subname, pyObj, mat, transform, depth)) {
return ret;
}
}
std::string name;
const char* dot = nullptr;
if (!subname || !(dot = strchr(subname, '.'))) {
ret = const_cast<DocumentObject*>(this);
}
else if (subname[0] == '$') {
name = std::string(subname + 1, dot);
for (auto obj : getOutList()) {
if (name == obj->Label.getValue()) {
ret = obj;
break;
}
}
}
else {
name = std::string(subname, dot);
const auto& outList = getOutList();
if (outList.size() != _outListMap.size()) {
_outListMap.clear();
for (auto obj : outList) {
_outListMap[obj->getDagKey()] = obj;
}
}
auto it = _outListMap.find(name.c_str());
if (it != _outListMap.end()) {
ret = it->second;
}
}
// TODO: By right, normal object's placement does not transform its sub
// objects (think of the claimed children of a Fusion). But I do think we
// should change that.
if (transform && mat) {
auto pla = freecad_cast<PropertyPlacement*>(getPropertyByName("Placement"));
if (pla) {
*mat *= pla->getValue().toMatrix();
}
}
if (ret && dot) {
return ret->getSubObject(dot + 1, pyObj, mat, true, depth + 1);
}
return ret;
}
namespace
{
std::vector<DocumentObject*>
getSubObjectListFlatten(const std::vector<App::DocumentObject*>& resNotFlatten,
std::vector<int>* const subsizes,
const App::DocumentObject* sobj,
App::DocumentObject** container,
bool& lastChild)
{
auto res {resNotFlatten};
auto linked = sobj->getLinkedObject();
if (*container) {
auto grp = App::GeoFeatureGroupExtension::getGroupOfObject(linked);
if (grp != *container) {
*container = nullptr;
}
else {
if (lastChild && !res.empty()) {
res.pop_back();
if (subsizes) {
subsizes->pop_back();
}
}
lastChild = true;
}
}
if (linked->getExtensionByType<App::GeoFeatureGroupExtension>(true)) {
*container = linked;
lastChild = false;
}
else if (linked != sobj || sobj->hasChildElement()) {
// Check for Link or LinkGroup
*container = nullptr;
}
else if (auto ext = sobj->getExtensionByType<LinkBaseExtension>(true)) {
// check for Link array
if (ext->getElementCountValue() != 0) {
*container = nullptr;
}
}
return res;
}
} // namespace
std::vector<DocumentObject*> DocumentObject::getSubObjectList(const char* subname,
std::vector<int>* const subsizes,
bool flatten) const
{
std::vector<DocumentObject*> res;
res.push_back(const_cast<DocumentObject*>(this));
if (subsizes) {
subsizes->push_back(0);
}
if (!subname || (subname[0] == '\0')) {
return res;
}
auto element = Data::findElementName(subname);
std::string sub(subname, element - subname);
App::DocumentObject* container = nullptr;
bool lastChild = false;
if (flatten) {
auto linked = getLinkedObject();
if (linked->getExtensionByType<App::GeoFeatureGroupExtension>(true)) {
container = const_cast<DocumentObject*>(this);
}
else if (auto grp = App::GeoFeatureGroupExtension::getGroupOfObject(linked)) {
container = grp;
lastChild = true;
}
}
for (auto pos = sub.find('.'); pos != std::string::npos; pos = sub.find('.', pos + 1)) {
char subTail = sub[pos + 1];
sub[pos + 1] = '\0';
auto sobj = getSubObject(sub.c_str());
if (!sobj || !sobj->isAttachedToDocument()) {
continue;
}
if (flatten) {
res = getSubObjectListFlatten(res, subsizes, sobj, &container, lastChild);
}
res.push_back(sobj);
if (subsizes) {
subsizes->push_back((int)pos + 1);
}
sub[pos + 1] = subTail;
}
return res;
}
std::vector<std::string> DocumentObject::getSubObjects(int reason) const
{
std::vector<std::string> ret;
auto exts = getExtensionsDerivedFromType<App::DocumentObjectExtension>();
for (auto ext : exts) {
if (ext->extensionGetSubObjects(ret, reason)) {
return ret;
}
}
return ret;
}
std::vector<std::pair<App::DocumentObject*, std::string>>
DocumentObject::getParents(int depth) const
{
std::vector<std::pair<App::DocumentObject*, std::string>> ret;
if (!isAttachedToDocument() || !GetApplication().checkLinkDepth(depth, MessageOption::Throw)) {
return ret;
}
std::string name(getNameInDocument());
name += ".";
for (auto parent : getInList()) {
if (!parent || !parent->isAttachedToDocument()) {
continue;
}
if (!parent->hasChildElement()
&& !parent->hasExtension(GeoFeatureGroupExtension::getExtensionClassTypeId())) {
continue;
}
if (!parent->getSubObject(name.c_str())) {
continue;
}
auto links = GetApplication().getLinksTo(parent, App::GetLinkRecursive);
links.insert(parent);
for (auto parent : links) {
auto parents = parent->getParents(depth + 1);
if (parents.empty()) {
parents.emplace_back(parent, std::string());
}
for (auto& v : parents) {
ret.emplace_back(v.first, v.second + name);
}
}
}
return ret;
}
App::DocumentObject* DocumentObject::getFirstParent() const
{
for (auto obj : getInList()) {
if (obj->hasExtension(App::GroupExtension::getExtensionClassTypeId(), true)) {
return obj;
}
}
return nullptr;
}
DocumentObject* DocumentObject::getLinkedObject(bool recursive,
Base::Matrix4D* mat,
bool transform,
int depth) const
{
DocumentObject* ret = nullptr;
auto exts = getExtensionsDerivedFromType<App::DocumentObjectExtension>();
for (auto ext : exts) {
if (ext->extensionGetLinkedObject(ret, recursive, mat, transform, depth)) {
return ret;
}
}
if (transform && mat) {
auto pla = freecad_cast<PropertyPlacement*>(getPropertyByName("Placement"));
if (pla) {
*mat *= pla->getValue().toMatrix();
}
}
return const_cast<DocumentObject*>(this);
}
void DocumentObject::Save(Base::Writer& writer) const
{
if (this->isFreezed()) {
throw Base::AbortException("At least one object is frozen, unable to save.");
}
if (this->isAttachedToDocument()){
writer.ObjectName = this->getNameInDocument();
}
App::ExtensionContainer::Save(writer);
}
/**
* @brief Associate the expression \expr with the object identifier \a path in this document object.
* @param path Target object identifier for the result of the expression
* @param expr Expression tree
*/
void DocumentObject::setExpression(const ObjectIdentifier& path, std::shared_ptr<Expression> expr)
{
ExpressionEngine.setValue(path, std::move(expr));
}
/**
* @brief Clear the expression of the object identifier \a path in this document object.
* @param path Target object identifier
*/
void DocumentObject::clearExpression(const ObjectIdentifier& path)
{
setExpression(path, std::shared_ptr<Expression>());
}
/**
* @brief Get expression information associated with \a path.
* @param path Object identifier
* @return Expression info, containing expression and optional comment.
*/
const PropertyExpressionEngine::ExpressionInfo
DocumentObject::getExpression(const ObjectIdentifier& path) const
{
boost::any value = ExpressionEngine.getPathValue(path);
if (value.type() == typeid(PropertyExpressionEngine::ExpressionInfo)) {
return boost::any_cast<PropertyExpressionEngine::ExpressionInfo>(value);
}
else {
return PropertyExpressionEngine::ExpressionInfo();
}
}
/**
* @brief Invoke ExpressionEngine's renameObjectIdentifier, to possibly rewrite expressions using
* the \a paths map with current and new identifiers.
*
* @param paths
*/
void DocumentObject::renameObjectIdentifiers(
const std::map<ObjectIdentifier, ObjectIdentifier>& paths)
{
ExpressionEngine.renameObjectIdentifiers(paths);
}
void DocumentObject::onDocumentRestored()
{
// call all extensions
auto vector = getExtensionsDerivedFromType<App::DocumentObjectExtension>();
for (auto ext : vector) {
ext->onExtendedDocumentRestored();
}
if (Visibility.testStatus(Property::Output)) {
Visibility.setStatus(Property::NoModify, true);
}
}
void DocumentObject::restoreFinished()
{
// some link type property cannot restore link information until other
// objects has been restored. For example, PropertyExpressionEngine and
// PropertySheet with expression containing label reference.
// So on document load they are handled in Document::afterRestore, but if the user
// use dumpContent and restoreContent then they need to be handled here.
std::vector<App::Property*> props;
getPropertyList(props);
for (auto prop : props) {
prop->afterRestore();
}
}
void DocumentObject::onUndoRedoFinished()
{}
void DocumentObject::onSettingDocument()
{
// call all extensions
auto vector = getExtensionsDerivedFromType<App::DocumentObjectExtension>();
for (auto ext : vector) {
ext->onExtendedSettingDocument();
}
}
void DocumentObject::setupObject()
{
// call all extensions
auto vector = getExtensionsDerivedFromType<App::DocumentObjectExtension>();
for (auto ext : vector) {
ext->onExtendedSetupObject();
}
}
void DocumentObject::unsetupObject()
{
// call all extensions
auto vector = getExtensionsDerivedFromType<App::DocumentObjectExtension>();
for (auto ext : vector) {
ext->onExtendedUnsetupObject();
}
}
void App::DocumentObject::_removeBackLink(DocumentObject* rmvObj)
{
// do not use erase-remove idom, as this erases ALL entries that match. we only want to remove a
// single one.
auto it = std::ranges::find(_inList, rmvObj);
if (it != _inList.end()) {
_inList.erase(it);
}
}
void App::DocumentObject::_addBackLink(DocumentObject* newObj)
{
// we need to add all links, even if they are available multiple times. The reason for this is
// the removal: If a link loses this object it removes the backlink. If we would have added it
// only once this removal would clear the object from the inlist, even though there may be other
// link properties from this object that link to us.
_inList.push_back(newObj);
}
int DocumentObject::setElementVisible(const char* element, bool visible)
{
for (auto ext : getExtensionsDerivedFromType<DocumentObjectExtension>()) {
int ret = ext->extensionSetElementVisible(element, visible);
if (ret >= 0) {
return ret;
}
}
return -1;
}
int DocumentObject::isElementVisible(const char* element) const
{
for (auto ext : getExtensionsDerivedFromType<DocumentObjectExtension>()) {
int ret = ext->extensionIsElementVisible(element);
if (ret >= 0) {
return ret;
}
}
return -1;
}
bool DocumentObject::hasChildElement() const
{
for (auto ext : getExtensionsDerivedFromType<DocumentObjectExtension>()) {
if (ext->extensionHasChildElement()) {
return true;
}
}
return false;
}
DocumentObject* DocumentObject::resolve(const char* subname,
App::DocumentObject** parent,
std::string* childName,
const char** subElement,
PyObject** pyObj,
Base::Matrix4D* pmat,
bool transform,
int depth) const
{
auto self = const_cast<DocumentObject*>(this);
if (parent) {
*parent = nullptr;
}
if (subElement) {
*subElement = nullptr;
}
auto obj = getSubObject(subname, pyObj, pmat, transform, depth);
if (!obj || !subname || *subname == 0) {
return self;
}
if (!parent && !subElement) {
return obj;
}
// NOTE, the convention of '.' separated SubName demands a mandatory ending
// '.' for each object name in SubName, even if there is no subelement
// following it. So finding the last dot will give us the end of the last
// object name.
const char* dot = nullptr;
if (Data::isMappedElement(subname) || !(dot = strrchr(subname, '.')) || dot == subname) {
if (subElement) {
*subElement = dot ? dot + 1 : subname;
}
return obj; // this means no parent object reference in SubName
}
if (parent) {
*parent = self;
}
bool elementMapChecked = false;
const char* lastDot = dot;
for (--dot;; --dot) {
// check for the second last dot, which is the end of the last parent object
if (*dot == '.' || dot == subname) {
// We can't get parent object by its name, because the object may be
// externally linked (i.e. in a different document). So go through
// getSubObject again.
if (!elementMapChecked) {
elementMapChecked = true;
const char* sub = dot == subname ? dot : dot + 1;
if (Data::isMappedElement(sub)) {
lastDot = dot;
if (dot == subname) {
break;
}
else {
continue;
}
}
}
if (dot == subname) {
break;
}
auto sobj = getSubObject(std::string(subname, dot - subname + 1).c_str());
if (sobj != obj) {
if (parent) {
// Link/LinkGroup has special visibility handling of plain
// group, so keep ascending
if (!sobj->hasExtension(GroupExtension::getExtensionClassTypeId(), false)) {
*parent = sobj;
break;
}
for (auto ddot = dot - 1; ddot != subname; --ddot) {
if (*ddot != '.') {
continue;
}
auto sobj = getSubObject(std::string(subname, ddot - subname + 1).c_str());
if (!sobj->hasExtension(GroupExtension::getExtensionClassTypeId(), false)) {
*parent = sobj;
break;
}
}
}
break;
}
}
}
if (childName && lastDot != dot) {
if (*dot == '.') {
++dot;
}
const char* nextDot = strchr(dot, '.');
assert(nextDot);
*childName = std::string(dot, nextDot - dot);
}
if (subElement) {
*subElement = *lastDot == '.' ? lastDot + 1 : lastDot;
}
return obj;
}
DocumentObject* DocumentObject::resolveRelativeLink(std::string& subname,
DocumentObject*& link,
std::string& linkSub) const
{
if (!link || !link->isAttachedToDocument() || !isAttachedToDocument()) {
return nullptr;
}
auto ret = const_cast<DocumentObject*>(this);
if (link != ret) {
auto sub = subname.c_str();
auto nextsub = sub;
for (auto dot = strchr(nextsub, '.'); dot; nextsub = dot + 1, dot = strchr(nextsub, '.')) {
std::string subcheck(sub, nextsub - sub);
subcheck += link->getNameInDocument();
subcheck += '.';
if (getSubObject(subcheck.c_str()) == link) {
ret = getSubObject(std::string(sub, dot + 1 - sub).c_str());
if (!ret) {
return nullptr;
}
subname = std::string(dot + 1);
break;
}
}
return ret;
}
size_t pos = 0, linkPos = 0;
std::string linkssub, ssub;
do {
linkPos = linkSub.find('.', linkPos);
if (linkPos == std::string::npos) {
link = nullptr;
return nullptr;
}
++linkPos;
pos = subname.find('.', pos);
if (pos == std::string::npos) {
subname.clear();
ret = nullptr;
break;
}
++pos;
} while (subname.compare(0, pos, linkSub, 0, linkPos) == 0);
if (pos != std::string::npos) {
ret = getSubObject(subname.substr(0, pos).c_str());
if (!ret) {
link = nullptr;
return nullptr;
}
subname = subname.substr(pos);
}
if (linkPos) {
link = link->getSubObject(linkSub.substr(0, linkPos).c_str());
if (!link) {
return nullptr;
}
linkSub = linkSub.substr(linkPos);
}
return ret;
}
bool DocumentObject::adjustRelativeLinks(const std::set<App::DocumentObject*>& inList,
std::set<App::DocumentObject*>* visited)
{
if (visited) {
visited->insert(this);
}
bool touched = false;
std::vector<Property*> props;
getPropertyList(props);
for (auto prop : props) {
auto linkProp = freecad_cast<PropertyLinkBase*>(prop);
if (linkProp && linkProp->adjustLink(inList)) {
touched = true;
}
}
if (visited) {
for (auto obj : getOutList()) {
if (!visited->count(obj)) {
if (obj->adjustRelativeLinks(inList, visited)) {
touched = true;
}
}
}
}
return touched;
}
std::string DocumentObject::getElementMapVersion(const App::Property* _prop, bool restored) const
{
auto prop = freecad_cast<const PropertyComplexGeoData*>(_prop);
if (!prop) {
return std::string();
}
return prop->getElementMapVersion(restored);
}
bool DocumentObject::checkElementMapVersion(const App::Property* _prop, const char* ver) const
{
auto prop = freecad_cast<const PropertyComplexGeoData*>(_prop);
if (!prop) {
return false;
}
return prop->checkElementMapVersion(ver);
}
const std::string& DocumentObject::hiddenMarker()
{
static std::string marker("!hide");
return marker;
}
const char* DocumentObject::hasHiddenMarker(const char* subname)
{
if (!subname) {
return nullptr;
}
const char* marker = strrchr(subname, '.');
if (!marker) {
marker = subname;
}
else {
++marker;
}
return hiddenMarker() == marker ? marker : nullptr;
}
bool DocumentObject::redirectSubName(std::ostringstream&, DocumentObject*, DocumentObject*) const
{
return false;
}
void DocumentObject::onPropertyStatusChanged(const Property& prop, unsigned long oldStatus)
{
(void)oldStatus;
if (!Document::isAnyRestoring() && isAttachedToDocument() && getDocument()) {
getDocument()->signalChangePropertyEditor(*getDocument(), prop);
}
}
Base::Placement DocumentObject::getPlacementOf(const std::string& sub, DocumentObject* targetObj)
{
Base::Placement plc;
auto* propPlacement = freecad_cast<App::PropertyPlacement*>(getPropertyByName("Placement"));
if (propPlacement) {
// If the object has no placement (like a Group), plc stays identity so we can proceed.
plc = propPlacement->getValue();
}
std::vector<std::string> names = Base::Tools::splitSubName(sub);
if (names.empty() || this == targetObj) {
return plc;
}
DocumentObject* subObj = getDocument()->getObject(names.front().c_str());
if (!subObj) {
return plc;
}
std::vector<std::string> newNames(names.begin() + 1, names.end());
std::string newSub = Base::Tools::joinList(newNames, ".");
return plc * subObj->getPlacementOf(newSub, targetObj);
}
Base::Placement DocumentObject::getPlacement() const
{
Base::Placement plc;
if (auto* prop = getPlacementProperty()) {
plc = prop->getValue();
}
return plc;
}
App::PropertyPlacement* DocumentObject::getPlacementProperty() const
{
if (auto linkExtension = getExtensionByType<App::LinkBaseExtension>(true)) {
if (auto linkPlacementProp = linkExtension->getLinkPlacementProperty()) {
return linkPlacementProp;
}
return linkExtension->getPlacementProperty();
}
return getPropertyByName<App::PropertyPlacement>("Placement");
}
Reference in New Issue View Git Blame Copy Permalink