FreeCAD / src /Mod /PartDesign /Gui /ReferenceSelection.cpp

Upload folder using huggingface_hub

985c397 verified 9 months ago

14.6 kB

/******************************************************************************
 *   Copyright (c) 2012 Konstantinos Poulios <logari81@gmail.com>             *
 *                                                                            *
 *   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 <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <QDialog>


#include <App/Document.h>
#include <App/Origin.h>
#include <App/Datums.h>
#include <App/Part.h>
#include <Base/Tools.h>
#include <Gui/Command.h>
#include <Gui/Document.h>
#include <Gui/MainWindow.h>
#include <Mod/Part/App/Part2DObject.h>
#include <Mod/Part/App/PartFeature.h>
#include <Mod/Part/App/TopoShape.h>
#include <Mod/PartDesign/App/Feature.h>
#include <Mod/PartDesign/App/Body.h>
#include <Mod/PartDesign/App/DatumLine.h>
#include <Mod/PartDesign/App/DatumPlane.h>
#include <Mod/PartDesign/App/DatumPoint.h>

#include "ui_DlgReference.h"
#include "ReferenceSelection.h"
#include "TaskFeaturePick.h"
#include "Utils.h"


using namespace PartDesignGui;
using namespace Gui;

/* TRANSLATOR PartDesignGui::ReferenceSelection.cpp */

bool ReferenceSelection::allow(App::Document* pDoc, App::DocumentObject* pObj, const char* sSubName)
{
    if (!pObj) {
        return false;
    }
    PartDesign::Body* body = getBody();
    App::OriginGroupExtension* originGroup = getOriginGroupExtension(body);

    // Don't allow selection in other document
    if (support && pDoc != support->getDocument()) {
        return false;
    }

    // Enable selection from origin of current part/
    if (pObj->isDerivedFrom<App::DatumElement>()) {
        return allowOrigin(body, originGroup, pObj);
    }

    if (pObj->isDerivedFrom<Part::Datum>()) {
        return allowDatum(body, pObj);
    }

    // The flag was used to be set. So, this block will never be treated and really doesn't make
    // sense anyway
#if 0
    if (!type.testFlag(AllowSelection::OTHERBODY)) {
        if (support == NULL)
            return false;
        if (pObj != support)
            return false;
    }
#endif
    if (pObj->isDerivedFrom<Part::Part2DObject>() && Base::Tools::isNullOrEmpty(sSubName)) {
        return type.testFlag(AllowSelection::FACE);
    }

    // Handle selection of geometry elements
    if (Base::Tools::isNullOrEmpty(sSubName)) {
        return type.testFlag(AllowSelection::WHOLE);
    }

    // resolve links if needed
    if (!pObj->isDerivedFrom<Part::Feature>()) {
        pObj = Part::Feature::getShapeOwner(pObj, sSubName);
    }

    if (pObj && pObj->isDerivedFrom<Part::Feature>()) {
        return allowPartFeature(pObj, sSubName);
    }

    return false;
}

PartDesign::Body* ReferenceSelection::getBody() const
{
    auto* body = support ? PartDesign::Body::findBodyOf(support) : PartDesignGui::getBody(false);
    return body;
}

App::OriginGroupExtension* ReferenceSelection::getOriginGroupExtension(PartDesign::Body* body) const
{
    App::DocumentObject* originGroupObject = nullptr;

    if (body) {  // Search for Part of the body
        originGroupObject = App::OriginGroupExtension::getGroupOfObject(body);
    }
    else if (support) {  // if no body search part for support
        originGroupObject = App::OriginGroupExtension::getGroupOfObject(support);
    }
    else {  // fallback to active part
        originGroupObject = PartDesignGui::getActivePart();
    }

    App::OriginGroupExtension* originGroup = nullptr;
    if (originGroupObject) {
        originGroup = originGroupObject->getExtensionByType<App::OriginGroupExtension>();
    }

    return originGroup;
}

bool ReferenceSelection::allowOrigin(
    PartDesign::Body* body,
    App::OriginGroupExtension* originGroup,
    App::DocumentObject* pObj
) const
{
    bool fits = false;
    if (type.testFlag(AllowSelection::FACE) && pObj->isDerivedFrom<App::Plane>()) {
        fits = true;
    }
    else if (type.testFlag(AllowSelection::EDGE) && pObj->isDerivedFrom<App::Line>()) {
        fits = true;
    }

    if (fits) {  // check that it actually belongs to the chosen body or part
        try {    // here are some throwers
            if (body) {
                if (body->hasObject(pObj, true)) {
                    return true;
                }
            }
            else if (originGroup) {
                if (originGroup->hasObject(pObj, true)) {
                    return true;
                }
            }
        }
        catch (const Base::Exception&) {
        }
    }
    return false;  // The Plane/Axis doesn't fits our needs
}

bool ReferenceSelection::allowDatum(PartDesign::Body* body, App::DocumentObject* pObj) const
{
    if (!body) {  // Allow selecting Part::Datum features from the active Body
        return false;
    }
    else if (!type.testFlag(AllowSelection::OTHERBODY) && !body->hasObject(pObj)) {
        return false;
    }

    if (type.testFlag(AllowSelection::FACE) && (pObj->isDerivedFrom<PartDesign::Plane>())) {
        return true;
    }
    if (type.testFlag(AllowSelection::EDGE) && (pObj->isDerivedFrom<PartDesign::Line>())) {
        return true;
    }
    if (type.testFlag(AllowSelection::POINT) && (pObj->isDerivedFrom<PartDesign::Point>())) {
        return true;
    }

    return false;
}

bool ReferenceSelection::allowPartFeature(App::DocumentObject* pObj, const char* sSubName) const
{
    std::string subName(sSubName);
    if (type.testFlag(AllowSelection::POINT) && subName.compare(0, 6, "Vertex") == 0) {
        return true;
    }

    if (type.testFlag(AllowSelection::EDGE) && subName.compare(0, 4, "Edge") == 0) {
        if (isEdge(pObj, sSubName)) {
            return true;
        }
    }

    if (type.testFlag(AllowSelection::CIRCLE) && subName.compare(0, 4, "Edge") == 0) {
        if (isCircle(pObj, sSubName)) {
            return true;
        }
    }

    if (type.testFlag(AllowSelection::FACE) && subName.compare(0, 4, "Face") == 0) {
        if (isFace(pObj, sSubName)) {
            return true;
        }
    }

    return false;
}

bool ReferenceSelection::isEdge(App::DocumentObject* pObj, const char* sSubName) const
{
    const Part::TopoShape& shape = static_cast<const Part::Feature*>(pObj)->Shape.getValue();
    TopoDS_Shape sh = shape.getSubShape(sSubName);
    const TopoDS_Edge& edgeShape = TopoDS::Edge(sh);
    if (!edgeShape.IsNull()) {
        if (type.testFlag(AllowSelection::PLANAR)) {
            BRepAdaptor_Curve adapt(edgeShape);
            if (adapt.GetType() == GeomAbs_Line) {
                return true;
            }
        }
        else {
            return true;
        }
    }

    return false;
}

bool ReferenceSelection::isFace(App::DocumentObject* pObj, const char* sSubName) const
{
    const Part::TopoShape& shape = static_cast<const Part::Feature*>(pObj)->Shape.getValue();
    TopoDS_Shape sh = shape.getSubShape(sSubName);
    const TopoDS_Face& face = TopoDS::Face(sh);
    if (!face.IsNull()) {
        if (type.testFlag(AllowSelection::PLANAR)) {
            BRepAdaptor_Surface adapt(face);
            if (adapt.GetType() == GeomAbs_Plane) {
                return true;
            }
        }
        else {
            return true;
        }
    }

    return false;
}

bool ReferenceSelection::isCircle(App::DocumentObject* pObj, const char* sSubName) const
{
    const Part::TopoShape& shape = static_cast<const Part::Feature*>(pObj)->Shape.getValue();
    TopoDS_Shape sh = shape.getSubShape(sSubName);
    const TopoDS_Edge& edgeShape = TopoDS::Edge(sh);
    BRepAdaptor_Curve adapt(edgeShape);
    if (adapt.GetType() == GeomAbs_Circle) {
        return true;
    }

    return false;
}

// ----------------------------------------------------------------------------

bool NoDependentsSelection::allow(App::Document* /*pDoc*/, App::DocumentObject* pObj, const char* /*sSubName*/)
{
    if (support && support->testIfLinkDAGCompatible(pObj)) {
        return true;
    }
    else {
        this->notAllowedReason = QT_TR_NOOP("Selecting this will cause circular dependency.");
        return false;
    }
}

bool CombineSelectionFilterGates::allow(App::Document* pDoc, App::DocumentObject* pObj, const char* sSubName)
{
    return filter1->allow(pDoc, pObj, sSubName) && filter2->allow(pDoc, pObj, sSubName);
}


namespace PartDesignGui
{

bool getReferencedSelection(
    const App::DocumentObject* thisObj,
    const Gui::SelectionChanges& msg,
    App::DocumentObject*& selObj,
    std::vector<std::string>& selSub
)
{
    selObj = nullptr;
    if (!thisObj) {
        return false;
    }

    if (strcmp(thisObj->getDocument()->getName(), msg.pDocName) != 0) {
        return false;
    }

    selObj = thisObj->getDocument()->getObject(msg.pObjectName);
    if (selObj == thisObj) {
        return false;
    }

    std::string subname = msg.pSubName;

    // check if the selection is an external reference and ask the user what to do
    // of course only if thisObj is in a body, as otherwise the old workflow would not
    // be supported
    PartDesign::Body* body = PartDesignGui::getBodyFor(thisObj, false);
    bool originfeature = selObj->isDerivedFrom<App::DatumElement>();
    if (!originfeature && body) {
        PartDesign::Body* selBody = PartDesignGui::getBodyFor(selObj, false);
        if (!selBody || body != selBody) {
            QDialog dia(Gui::getMainWindow());
            Ui_DlgReference dlg;
            dlg.setupUi(&dia);
            dia.setModal(true);
            int result = dia.exec();
            if (result == QDialog::DialogCode::Rejected) {
                selObj = nullptr;
                return false;
            }

            if (!dlg.radioXRef->isChecked()) {
                App::Document* document = thisObj->getDocument();
                document->openTransaction("Make copy");
                auto copy = PartDesignGui::TaskFeaturePick::makeCopy(
                    selObj,
                    subname,
                    dlg.radioIndependent->isChecked()
                );
                body->addObject(copy);

                selObj = copy;
                subname.erase(std::remove_if(subname.begin(), subname.end(), &isdigit), subname.end());
                subname.append("1");
            }
        }
    }

    // Remove subname for planes and datum features
    if (PartDesign::Feature::isDatum(selObj)) {
        subname = "";
    }

    selSub = std::vector<std::string>(1, subname);

    return true;
}

QString getRefStr(const App::DocumentObject* obj, const std::vector<std::string>& sub)
{
    if (!obj) {
        return {};
    }

    if (PartDesign::Feature::isDatum(obj)) {
        return QString::fromLatin1(obj->getNameInDocument());
    }

    if (!sub.empty() && !sub.front().empty()) {
        return QString::fromLatin1(obj->getNameInDocument()) + QStringLiteral(":")
            + QString::fromLatin1(sub.front().c_str());
    }

    if (obj->isDerivedFrom<Part::Part2DObject>()) {
        // only return bare name for sketches when no subelement is specified
        return QString::fromLatin1(obj->getNameInDocument());
    }

    return {};
}

std::string buildLinkSubPythonStr(const App::DocumentObject* obj, const std::vector<std::string>& subs)
{
    if (!obj) {
        return "None";
    }

    std::string result("[");

    for (const auto& sub : subs) {
        result += "\"" + sub + "\",";
    }
    result += "]";

    return result;
}

std::string buildLinkSingleSubPythonStr(
    const App::DocumentObject* obj,
    const std::vector<std::string>& subs
)
{
    if (!obj) {
        return "None";
    }

    if (PartDesign::Feature::isDatum(obj)) {
        return Gui::Command::getObjectCmd(obj, "(", ", [''])");
    }
    else {
        return Gui::Command::getObjectCmd(obj, "(", ", ['") + subs.front() + "'])";
    }
}

std::string buildLinkListPythonStr(const std::vector<App::DocumentObject*>& objs)
{
    if (objs.empty()) {
        return "None";
    }

    std::string result("[");

    for (auto obj : objs) {
        result += Gui::Command::getObjectCmd(obj, nullptr, ",");
    }
    result += "]";

    return result;
}

std::string buildLinkSubListPythonStr(
    const std::vector<App::DocumentObject*>& objs,
    const std::vector<std::string>& subs
)
{
    if (objs.empty()) {
        return "None";
    }

    std::string result("[");

    assert(objs.size() == subs.size());

    for (size_t i = 0, objs_sz = objs.size(); i < objs_sz; i++) {
        if (objs[i]) {
            result += '(';
            result += Gui::Command::getObjectCmd(objs[i]);
            result += ",\"";
            result += subs[i];
            result += "\"),";
        }
    }

    result += "]";

    return result;
}
}  // namespace PartDesignGui

	/******************************************************************************
	* Copyright (c) 2012 Konstantinos Poulios <logari81@gmail.com> *
	* *
	* 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 <BRepAdaptor_Curve.hxx>
	#include <BRepAdaptor_Surface.hxx>
	#include <TopoDS.hxx>
	#include <TopoDS_Edge.hxx>
	#include <TopoDS_Face.hxx>
	#include <QDialog>


	#include <App/Document.h>
	#include <App/Origin.h>
	#include <App/Datums.h>
	#include <App/Part.h>
	#include <Base/Tools.h>
	#include <Gui/Command.h>
	#include <Gui/Document.h>
	#include <Gui/MainWindow.h>
	#include <Mod/Part/App/Part2DObject.h>
	#include <Mod/Part/App/PartFeature.h>
	#include <Mod/Part/App/TopoShape.h>
	#include <Mod/PartDesign/App/Feature.h>
	#include <Mod/PartDesign/App/Body.h>
	#include <Mod/PartDesign/App/DatumLine.h>
	#include <Mod/PartDesign/App/DatumPlane.h>
	#include <Mod/PartDesign/App/DatumPoint.h>

	#include "ui_DlgReference.h"
	#include "ReferenceSelection.h"
	#include "TaskFeaturePick.h"
	#include "Utils.h"


	using namespace PartDesignGui;
	using namespace Gui;

	/* TRANSLATOR PartDesignGui::ReferenceSelection.cpp */

	bool ReferenceSelection::allow(App::Document* pDoc, App::DocumentObject* pObj, const char* sSubName)
	{
	if (!pObj) {
	return false;
	}
	PartDesign::Body* body = getBody();
	App::OriginGroupExtension* originGroup = getOriginGroupExtension(body);

	// Don't allow selection in other document
	if (support && pDoc != support->getDocument()) {
	return false;
	}

	// Enable selection from origin of current part/
	if (pObj->isDerivedFrom<App::DatumElement>()) {
	return allowOrigin(body, originGroup, pObj);
	}

	if (pObj->isDerivedFrom<Part::Datum>()) {
	return allowDatum(body, pObj);
	}

	// The flag was used to be set. So, this block will never be treated and really doesn't make
	// sense anyway
	#if 0
	if (!type.testFlag(AllowSelection::OTHERBODY)) {
	if (support == NULL)
	return false;
	if (pObj != support)
	return false;
	}
	#endif
	if (pObj->isDerivedFrom<Part::Part2DObject>() && Base::Tools::isNullOrEmpty(sSubName)) {
	return type.testFlag(AllowSelection::FACE);
	}

	// Handle selection of geometry elements
	if (Base::Tools::isNullOrEmpty(sSubName)) {
	return type.testFlag(AllowSelection::WHOLE);
	}

	// resolve links if needed
	if (!pObj->isDerivedFrom<Part::Feature>()) {
	pObj = Part::Feature::getShapeOwner(pObj, sSubName);
	}

	if (pObj && pObj->isDerivedFrom<Part::Feature>()) {
	return allowPartFeature(pObj, sSubName);
	}

	return false;
	}

	PartDesign::Body* ReferenceSelection::getBody() const
	{
	auto* body = support ? PartDesign::Body::findBodyOf(support) : PartDesignGui::getBody(false);
	return body;
	}

	App::OriginGroupExtension* ReferenceSelection::getOriginGroupExtension(PartDesign::Body* body) const
	{
	App::DocumentObject* originGroupObject = nullptr;

	if (body) { // Search for Part of the body
	originGroupObject = App::OriginGroupExtension::getGroupOfObject(body);
	}
	else if (support) { // if no body search part for support
	originGroupObject = App::OriginGroupExtension::getGroupOfObject(support);
	}
	else { // fallback to active part
	originGroupObject = PartDesignGui::getActivePart();
	}

	App::OriginGroupExtension* originGroup = nullptr;
	if (originGroupObject) {
	originGroup = originGroupObject->getExtensionByType<App::OriginGroupExtension>();
	}

	return originGroup;
	}

	bool ReferenceSelection::allowOrigin(
	PartDesign::Body* body,
	App::OriginGroupExtension* originGroup,
	App::DocumentObject* pObj
	) const
	{
	bool fits = false;
	if (type.testFlag(AllowSelection::FACE) && pObj->isDerivedFrom<App::Plane>()) {
	fits = true;
	}
	else if (type.testFlag(AllowSelection::EDGE) && pObj->isDerivedFrom<App::Line>()) {
	fits = true;
	}

	if (fits) { // check that it actually belongs to the chosen body or part
	try { // here are some throwers
	if (body) {
	if (body->hasObject(pObj, true)) {
	return true;
	}
	}
	else if (originGroup) {
	if (originGroup->hasObject(pObj, true)) {
	return true;
	}
	}
	}
	catch (const Base::Exception&) {
	}
	}
	return false; // The Plane/Axis doesn't fits our needs
	}

	bool ReferenceSelection::allowDatum(PartDesign::Body* body, App::DocumentObject* pObj) const
	{
	if (!body) { // Allow selecting Part::Datum features from the active Body
	return false;
	}
	else if (!type.testFlag(AllowSelection::OTHERBODY) && !body->hasObject(pObj)) {
	return false;
	}

	if (type.testFlag(AllowSelection::FACE) && (pObj->isDerivedFrom<PartDesign::Plane>())) {
	return true;
	}
	if (type.testFlag(AllowSelection::EDGE) && (pObj->isDerivedFrom<PartDesign::Line>())) {
	return true;
	}
	if (type.testFlag(AllowSelection::POINT) && (pObj->isDerivedFrom<PartDesign::Point>())) {
	return true;
	}

	return false;
	}

	bool ReferenceSelection::allowPartFeature(App::DocumentObject* pObj, const char* sSubName) const
	{
	std::string subName(sSubName);
	if (type.testFlag(AllowSelection::POINT) && subName.compare(0, 6, "Vertex") == 0) {
	return true;
	}

	if (type.testFlag(AllowSelection::EDGE) && subName.compare(0, 4, "Edge") == 0) {
	if (isEdge(pObj, sSubName)) {
	return true;
	}
	}

	if (type.testFlag(AllowSelection::CIRCLE) && subName.compare(0, 4, "Edge") == 0) {
	if (isCircle(pObj, sSubName)) {
	return true;
	}
	}

	if (type.testFlag(AllowSelection::FACE) && subName.compare(0, 4, "Face") == 0) {
	if (isFace(pObj, sSubName)) {
	return true;
	}
	}

	return false;
	}

	bool ReferenceSelection::isEdge(App::DocumentObject* pObj, const char* sSubName) const
	{
	const Part::TopoShape& shape = static_cast<const Part::Feature*>(pObj)->Shape.getValue();
	TopoDS_Shape sh = shape.getSubShape(sSubName);
	const TopoDS_Edge& edgeShape = TopoDS::Edge(sh);
	if (!edgeShape.IsNull()) {
	if (type.testFlag(AllowSelection::PLANAR)) {
	BRepAdaptor_Curve adapt(edgeShape);
	if (adapt.GetType() == GeomAbs_Line) {
	return true;
	}
	}
	else {
	return true;
	}
	}

	return false;
	}

	bool ReferenceSelection::isFace(App::DocumentObject* pObj, const char* sSubName) const
	{
	const Part::TopoShape& shape = static_cast<const Part::Feature*>(pObj)->Shape.getValue();
	TopoDS_Shape sh = shape.getSubShape(sSubName);
	const TopoDS_Face& face = TopoDS::Face(sh);
	if (!face.IsNull()) {
	if (type.testFlag(AllowSelection::PLANAR)) {
	BRepAdaptor_Surface adapt(face);
	if (adapt.GetType() == GeomAbs_Plane) {
	return true;
	}
	}
	else {
	return true;
	}
	}

	return false;
	}

	bool ReferenceSelection::isCircle(App::DocumentObject* pObj, const char* sSubName) const
	{
	const Part::TopoShape& shape = static_cast<const Part::Feature*>(pObj)->Shape.getValue();
	TopoDS_Shape sh = shape.getSubShape(sSubName);
	const TopoDS_Edge& edgeShape = TopoDS::Edge(sh);
	BRepAdaptor_Curve adapt(edgeShape);
	if (adapt.GetType() == GeomAbs_Circle) {
	return true;
	}

	return false;
	}

	// ----------------------------------------------------------------------------

	bool NoDependentsSelection::allow(App::Document* /pDoc/, App::DocumentObject* pObj, const char* /sSubName/)
	{
	if (support && support->testIfLinkDAGCompatible(pObj)) {
	return true;
	}
	else {
	this->notAllowedReason = QT_TR_NOOP("Selecting this will cause circular dependency.");
	return false;
	}
	}

	bool CombineSelectionFilterGates::allow(App::Document* pDoc, App::DocumentObject* pObj, const char* sSubName)
	{
	return filter1->allow(pDoc, pObj, sSubName) && filter2->allow(pDoc, pObj, sSubName);
	}


	namespace PartDesignGui
	{

	bool getReferencedSelection(
	const App::DocumentObject* thisObj,
	const Gui::SelectionChanges& msg,
	App::DocumentObject*& selObj,
	std::vector<std::string>& selSub
	)
	{
	selObj = nullptr;
	if (!thisObj) {
	return false;
	}

	if (strcmp(thisObj->getDocument()->getName(), msg.pDocName) != 0) {
	return false;
	}

	selObj = thisObj->getDocument()->getObject(msg.pObjectName);
	if (selObj == thisObj) {
	return false;
	}

	std::string subname = msg.pSubName;

	// check if the selection is an external reference and ask the user what to do
	// of course only if thisObj is in a body, as otherwise the old workflow would not
	// be supported
	PartDesign::Body* body = PartDesignGui::getBodyFor(thisObj, false);
	bool originfeature = selObj->isDerivedFrom<App::DatumElement>();
	if (!originfeature && body) {
	PartDesign::Body* selBody = PartDesignGui::getBodyFor(selObj, false);
	if (!selBody \|\| body != selBody) {
	QDialog dia(Gui::getMainWindow());
	Ui_DlgReference dlg;
	dlg.setupUi(&dia);
	dia.setModal(true);
	int result = dia.exec();
	if (result == QDialog::DialogCode::Rejected) {
	selObj = nullptr;
	return false;
	}

	if (!dlg.radioXRef->isChecked()) {
	App::Document* document = thisObj->getDocument();
	document->openTransaction("Make copy");
	auto copy = PartDesignGui::TaskFeaturePick::makeCopy(
	selObj,
	subname,
	dlg.radioIndependent->isChecked()
	);
	body->addObject(copy);

	selObj = copy;
	subname.erase(std::remove_if(subname.begin(), subname.end(), &isdigit), subname.end());
	subname.append("1");
	}
	}
	}

	// Remove subname for planes and datum features
	if (PartDesign::Feature::isDatum(selObj)) {
	subname = "";
	}

	selSub = std::vector<std::string>(1, subname);

	return true;
	}

	QString getRefStr(const App::DocumentObject* obj, const std::vector<std::string>& sub)
	{
	if (!obj) {
	return {};
	}

	if (PartDesign::Feature::isDatum(obj)) {
	return QString::fromLatin1(obj->getNameInDocument());
	}

	if (!sub.empty() && !sub.front().empty()) {
	return QString::fromLatin1(obj->getNameInDocument()) + QStringLiteral(":")
	+ QString::fromLatin1(sub.front().c_str());
	}

	if (obj->isDerivedFrom<Part::Part2DObject>()) {
	// only return bare name for sketches when no subelement is specified
	return QString::fromLatin1(obj->getNameInDocument());
	}

	return {};
	}

	std::string buildLinkSubPythonStr(const App::DocumentObject* obj, const std::vector<std::string>& subs)
	{
	if (!obj) {
	return "None";
	}

	std::string result("[");

	for (const auto& sub : subs) {
	result += "\"" + sub + "\",";
	}
	result += "]";

	return result;
	}

	std::string buildLinkSingleSubPythonStr(
	const App::DocumentObject* obj,
	const std::vector<std::string>& subs
	)
	{
	if (!obj) {
	return "None";
	}

	if (PartDesign::Feature::isDatum(obj)) {
	return Gui::Command::getObjectCmd(obj, "(", ", [''])");
	}
	else {
	return Gui::Command::getObjectCmd(obj, "(", ", ['") + subs.front() + "'])";
	}
	}

	std::string buildLinkListPythonStr(const std::vector<App::DocumentObject*>& objs)
	{
	if (objs.empty()) {
	return "None";
	}

	std::string result("[");

	for (auto obj : objs) {
	result += Gui::Command::getObjectCmd(obj, nullptr, ",");
	}
	result += "]";

	return result;
	}

	std::string buildLinkSubListPythonStr(
	const std::vector<App::DocumentObject*>& objs,
	const std::vector<std::string>& subs
	)
	{
	if (objs.empty()) {
	return "None";
	}

	std::string result("[");

	assert(objs.size() == subs.size());

	for (size_t i = 0, objs_sz = objs.size(); i < objs_sz; i++) {
	if (objs[i]) {
	result += '(';
	result += Gui::Command::getObjectCmd(objs[i]);
	result += ",\"";
	result += subs[i];
	result += "\"),";
	}
	}

	result += "]";

	return result;
	}
	} // namespace PartDesignGui