3152 lines
94 KiB
C++
3152 lines
94 KiB
C++
// 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 <array>
|
|
#include <set>
|
|
#include <boost/algorithm/string/predicate.hpp>
|
|
#include <QApplication>
|
|
|
|
|
|
#include <App/Application.h>
|
|
#include <App/Document.h>
|
|
#include <App/DocumentObject.h>
|
|
#include <App/DocumentObjectPy.h>
|
|
#include <App/GeoFeature.h>
|
|
#include <Base/Console.h>
|
|
#include <Base/Exception.h>
|
|
#include <Base/Interpreter.h>
|
|
#include <Base/Tools.h>
|
|
#include <Base/PyWrapParseTupleAndKeywords.h>
|
|
#include <Base/UnitsApi.h>
|
|
|
|
#include "Selection.h"
|
|
#include "SelectionObject.h"
|
|
#include "Application.h"
|
|
#include "Document.h"
|
|
#include "Macro.h"
|
|
#include "MainWindow.h"
|
|
#include "MDIView.h"
|
|
#include "SelectionFilter.h"
|
|
#include "SelectionFilterPy.h"
|
|
#include "SelectionObserverPython.h"
|
|
#include "Tree.h"
|
|
#include "ViewProvider.h"
|
|
#include "ViewProviderDocumentObject.h"
|
|
|
|
|
|
FC_LOG_LEVEL_INIT("Selection", false, true, true)
|
|
|
|
using namespace Gui;
|
|
using namespace std;
|
|
namespace sp = std::placeholders;
|
|
|
|
SelectionGateFilterExternal::SelectionGateFilterExternal(const char* docName, const char* objName)
|
|
{
|
|
if (docName) {
|
|
DocName = docName;
|
|
if (objName) {
|
|
ObjName = objName;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool SelectionGateFilterExternal::allow(App::Document* doc, App::DocumentObject* obj, const char*)
|
|
{
|
|
if (!doc || !obj) {
|
|
return true;
|
|
}
|
|
if (!DocName.empty() && doc->getName() != DocName) {
|
|
notAllowedReason = "Cannot select external object";
|
|
}
|
|
else if (!ObjName.empty() && ObjName == obj->getNameInDocument()) {
|
|
notAllowedReason = "Cannot select self";
|
|
}
|
|
else {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
SelectionObserver::SelectionObserver(bool attach, ResolveMode resolve)
|
|
: resolve(resolve)
|
|
, blockedSelection(false)
|
|
{
|
|
if (attach) {
|
|
attachSelection();
|
|
}
|
|
}
|
|
|
|
SelectionObserver::SelectionObserver(const ViewProviderDocumentObject* vp, bool attach, ResolveMode resolve)
|
|
: resolve(resolve)
|
|
, blockedSelection(false)
|
|
{
|
|
if (vp && vp->getObject() && vp->getObject()->getDocument()) {
|
|
filterDocName = vp->getObject()->getDocument()->getName();
|
|
filterObjName = vp->getObject()->getNameInDocument();
|
|
}
|
|
if (attach) {
|
|
attachSelection();
|
|
}
|
|
}
|
|
|
|
|
|
SelectionObserver::~SelectionObserver()
|
|
{
|
|
detachSelection();
|
|
}
|
|
|
|
bool SelectionObserver::blockSelection(bool block)
|
|
{
|
|
bool ok = blockedSelection;
|
|
blockedSelection = block;
|
|
return ok;
|
|
}
|
|
|
|
bool SelectionObserver::isSelectionBlocked() const
|
|
{
|
|
return blockedSelection;
|
|
}
|
|
|
|
bool SelectionObserver::isSelectionAttached() const
|
|
{
|
|
return connectSelection.connected();
|
|
}
|
|
|
|
void SelectionObserver::attachSelection()
|
|
{
|
|
if (!connectSelection.connected()) {
|
|
bool newStyle = (resolve >= ResolveMode::NewStyleElement);
|
|
bool oldStyle = (resolve == ResolveMode::OldStyleElement);
|
|
auto& signal = newStyle ? Selection().signalSelectionChanged3
|
|
: oldStyle ? Selection().signalSelectionChanged2
|
|
: Selection().signalSelectionChanged;
|
|
// NOLINTBEGIN
|
|
connectSelection = signal.connect(
|
|
std::bind(&SelectionObserver::_onSelectionChanged, this, sp::_1)
|
|
);
|
|
// NOLINTEND
|
|
|
|
if (!filterDocName.empty()) {
|
|
Selection().addSelectionGate(
|
|
new SelectionGateFilterExternal(filterDocName.c_str(), filterObjName.c_str())
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SelectionObserver::_onSelectionChanged(const SelectionChanges& msg)
|
|
{
|
|
try {
|
|
if (blockedSelection) {
|
|
return;
|
|
}
|
|
onSelectionChanged(msg);
|
|
}
|
|
catch (Base::Exception& e) {
|
|
e.reportException();
|
|
FC_ERR("Unhandled Base::Exception caught in selection observer: ");
|
|
}
|
|
catch (std::exception& e) {
|
|
FC_ERR("Unhandled std::exception caught in selection observer: " << e.what());
|
|
}
|
|
catch (...) {
|
|
FC_ERR("Unhandled unknown exception caught in selection observer");
|
|
}
|
|
}
|
|
|
|
void SelectionObserver::detachSelection()
|
|
{
|
|
if (connectSelection.connected()) {
|
|
connectSelection.disconnect();
|
|
if (!filterDocName.empty()) {
|
|
Selection().rmvSelectionGate();
|
|
}
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------
|
|
|
|
bool SelectionSingleton::hasSelection() const
|
|
{
|
|
return !_SelList.empty();
|
|
}
|
|
|
|
bool SelectionSingleton::hasPreselection() const
|
|
{
|
|
return !CurrentPreselection.Object.getObjectName().empty();
|
|
}
|
|
|
|
std::vector<SelectionSingleton::SelObj> SelectionSingleton::getCompleteSelection(ResolveMode resolve) const
|
|
{
|
|
return getSelection("*", resolve);
|
|
}
|
|
|
|
std::vector<SelectionSingleton::SelObj> SelectionSingleton::getSelection(
|
|
const char* pDocName,
|
|
ResolveMode resolve,
|
|
bool single
|
|
) const
|
|
{
|
|
std::vector<SelObj> temp;
|
|
if (single) {
|
|
temp.reserve(1);
|
|
}
|
|
SelObj tempSelObj;
|
|
|
|
App::Document* pcDoc = nullptr;
|
|
if (!pDocName || strcmp(pDocName, "*") != 0) {
|
|
pcDoc = getDocument(pDocName);
|
|
if (!pcDoc) {
|
|
return temp;
|
|
}
|
|
}
|
|
|
|
std::map<App::DocumentObject*, std::set<std::string>> objMap;
|
|
|
|
for (auto& sel : _SelList) {
|
|
if (!sel.pDoc) {
|
|
continue;
|
|
}
|
|
const char* subelement = nullptr;
|
|
auto obj = getObjectOfType(sel, App::DocumentObject::getClassTypeId(), resolve, &subelement);
|
|
if (!obj || (pcDoc && sel.pObject->getDocument() != pcDoc)) {
|
|
continue;
|
|
}
|
|
|
|
// In case we are resolving objects, make sure no duplicates
|
|
if (resolve != ResolveMode::NoResolve
|
|
&& !objMap[obj].insert(std::string(subelement ? subelement : "")).second) {
|
|
continue;
|
|
}
|
|
|
|
if (single && !temp.empty()) {
|
|
temp.clear();
|
|
break;
|
|
}
|
|
|
|
tempSelObj.DocName = obj->getDocument()->getName();
|
|
tempSelObj.FeatName = obj->getNameInDocument();
|
|
tempSelObj.SubName = subelement;
|
|
tempSelObj.TypeName = obj->getTypeId().getName();
|
|
tempSelObj.pObject = obj;
|
|
tempSelObj.pResolvedObject = sel.pResolvedObject;
|
|
tempSelObj.pDoc = obj->getDocument();
|
|
tempSelObj.x = sel.x;
|
|
tempSelObj.y = sel.y;
|
|
tempSelObj.z = sel.z;
|
|
|
|
temp.push_back(tempSelObj);
|
|
}
|
|
|
|
return temp;
|
|
}
|
|
|
|
bool SelectionSingleton::hasSelection(const char* doc, ResolveMode resolve) const
|
|
{
|
|
App::Document* pcDoc = nullptr;
|
|
if (!doc || strcmp(doc, "*") != 0) {
|
|
pcDoc = getDocument(doc);
|
|
if (!pcDoc) {
|
|
return false;
|
|
}
|
|
}
|
|
for (auto& sel : _SelList) {
|
|
if (!sel.pDoc) {
|
|
continue;
|
|
}
|
|
auto obj = getObjectOfType(sel, App::DocumentObject::getClassTypeId(), resolve);
|
|
if (obj && (!pcDoc || sel.pObject->getDocument() == pcDoc)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool SelectionSingleton::hasSubSelection(const char* doc, bool subElement) const
|
|
{
|
|
App::Document* pcDoc = nullptr;
|
|
if (!doc || strcmp(doc, "*") != 0) {
|
|
pcDoc = getDocument(doc);
|
|
if (!pcDoc) {
|
|
return false;
|
|
}
|
|
}
|
|
for (auto& sel : _SelList) {
|
|
if (pcDoc && pcDoc != sel.pDoc) {
|
|
continue;
|
|
}
|
|
if (sel.SubName.empty()) {
|
|
continue;
|
|
}
|
|
if (subElement && sel.SubName.back() != '.') {
|
|
return true;
|
|
}
|
|
if (sel.pObject != sel.pResolvedObject) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
std::vector<SelectionSingleton::SelObj> SelectionSingleton::getPickedList(const char* pDocName) const
|
|
{
|
|
std::vector<SelObj> temp;
|
|
SelObj tempSelObj;
|
|
|
|
App::Document* pcDoc = nullptr;
|
|
if (!pDocName || strcmp(pDocName, "*") != 0) {
|
|
pcDoc = getDocument(pDocName);
|
|
if (!pcDoc) {
|
|
return temp;
|
|
}
|
|
}
|
|
|
|
for (std::list<_SelObj>::const_iterator It = _PickedList.begin(); It != _PickedList.end(); ++It) {
|
|
if (!pcDoc || It->pDoc == pcDoc) {
|
|
tempSelObj.DocName = It->DocName.c_str();
|
|
tempSelObj.FeatName = It->FeatName.c_str();
|
|
tempSelObj.SubName = It->SubName.c_str();
|
|
tempSelObj.TypeName = It->TypeName.c_str();
|
|
tempSelObj.pObject = It->pObject;
|
|
tempSelObj.pResolvedObject = It->pResolvedObject;
|
|
tempSelObj.pDoc = It->pDoc;
|
|
tempSelObj.x = It->x;
|
|
tempSelObj.y = It->y;
|
|
tempSelObj.z = It->z;
|
|
temp.push_back(tempSelObj);
|
|
}
|
|
}
|
|
|
|
return temp;
|
|
}
|
|
|
|
std::vector<Gui::SelectionObject> SelectionSingleton::getSelectionIn(
|
|
App::DocumentObject* container,
|
|
Base::Type typeId,
|
|
bool single
|
|
) const
|
|
{
|
|
if (!container) {
|
|
return getSelectionEx(nullptr, typeId, ResolveMode::NoResolve, single);
|
|
}
|
|
|
|
std::vector<SelectionObject> sels
|
|
= getSelectionEx(nullptr, App::DocumentObject::getClassTypeId(), ResolveMode::NoResolve, single);
|
|
|
|
std::vector<SelectionObject> ret;
|
|
std::map<App::DocumentObject*, size_t> SortMap;
|
|
|
|
for (auto& sel : sels) {
|
|
auto* rootObj = sel.getObject();
|
|
App::Document* doc = rootObj->getDocument();
|
|
std::vector<std::string> subs = sel.getSubNames();
|
|
bool objPassed = false;
|
|
|
|
for (size_t i = 0; i < subs.size(); ++i) {
|
|
auto& sub = subs[i];
|
|
App::DocumentObject* newRootObj = nullptr;
|
|
std::string newSub = "";
|
|
|
|
std::vector<std::string> names = Base::Tools::splitSubName(sub);
|
|
|
|
if (container == rootObj) {
|
|
objPassed = true;
|
|
}
|
|
|
|
if (rootObj->isLink()) {
|
|
// Update doc in case its an external link.
|
|
doc = rootObj->getLinkedObject()->getDocument();
|
|
}
|
|
|
|
for (auto& name : names) {
|
|
App::DocumentObject* obj = doc->getObject(name.c_str());
|
|
if (!obj) { // We reached the element name (for example 'edge1')
|
|
newSub += name;
|
|
break;
|
|
}
|
|
|
|
if (objPassed) {
|
|
if (!newRootObj) {
|
|
// We are the first object after the container is passed.
|
|
newRootObj = obj;
|
|
}
|
|
else {
|
|
newSub += name + ".";
|
|
}
|
|
}
|
|
|
|
if (obj == container) {
|
|
objPassed = true;
|
|
}
|
|
if (obj->isLink()) {
|
|
// Update doc in case its an external link.
|
|
doc = obj->getLinkedObject()->getDocument();
|
|
}
|
|
}
|
|
|
|
if (newRootObj) {
|
|
// Make sure selected object is of correct type
|
|
auto* lastObj = newRootObj->resolve(newSub.c_str());
|
|
if (!lastObj || !lastObj->isDerivedFrom(typeId)) {
|
|
continue;
|
|
}
|
|
|
|
auto it = SortMap.find(newRootObj);
|
|
if (it != SortMap.end()) {
|
|
// only add sub-element
|
|
if (newSub != "") {
|
|
ret[it->second].SubNames.emplace_back(newSub);
|
|
ret[it->second].SelPoses.emplace_back(sel.SelPoses[i]);
|
|
}
|
|
}
|
|
else {
|
|
if (single && !ret.empty()) {
|
|
ret.clear();
|
|
break;
|
|
}
|
|
// create a new entry
|
|
ret.emplace_back(newRootObj);
|
|
if (newSub != "") {
|
|
ret.back().SubNames.emplace_back(newSub);
|
|
ret.back().SelPoses.emplace_back(sel.SelPoses[i]);
|
|
}
|
|
SortMap.insert(std::make_pair(newRootObj, ret.size() - 1));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
std::vector<SelectionObject> SelectionSingleton::getSelectionEx(
|
|
const char* pDocName,
|
|
Base::Type typeId,
|
|
ResolveMode resolve,
|
|
bool single
|
|
) const
|
|
{
|
|
return getObjectList(pDocName, typeId, _SelList, resolve, single);
|
|
}
|
|
|
|
std::vector<SelectionObject> SelectionSingleton::getPickedListEx(
|
|
const char* pDocName,
|
|
Base::Type typeId
|
|
) const
|
|
{
|
|
return getObjectList(pDocName, typeId, _PickedList, ResolveMode::NoResolve);
|
|
}
|
|
|
|
std::vector<SelectionObject> SelectionSingleton::getObjectList(
|
|
const char* pDocName,
|
|
Base::Type typeId,
|
|
std::list<_SelObj>& objList,
|
|
ResolveMode resolve,
|
|
bool single
|
|
) const
|
|
{
|
|
std::vector<SelectionObject> temp;
|
|
if (single) {
|
|
temp.reserve(1);
|
|
}
|
|
std::map<App::DocumentObject*, size_t> SortMap;
|
|
|
|
// check the type
|
|
if (typeId.isBad()) {
|
|
return temp;
|
|
}
|
|
|
|
App::Document* pcDoc = nullptr;
|
|
if (!pDocName || strcmp(pDocName, "*") != 0) {
|
|
pcDoc = getDocument(pDocName);
|
|
if (!pcDoc) {
|
|
return temp;
|
|
}
|
|
}
|
|
|
|
for (auto& sel : objList) {
|
|
if (!sel.pDoc) {
|
|
continue;
|
|
}
|
|
const char* subelement = nullptr;
|
|
auto obj = getObjectOfType(sel, typeId, resolve, &subelement);
|
|
if (!obj || (pcDoc && sel.pObject->getDocument() != pcDoc)) {
|
|
continue;
|
|
}
|
|
auto it = SortMap.find(obj);
|
|
if (it != SortMap.end()) {
|
|
// only add sub-element
|
|
if (subelement && *subelement) {
|
|
if (resolve != ResolveMode::NoResolve
|
|
&& !temp[it->second]._SubNameSet.insert(subelement).second) {
|
|
continue;
|
|
}
|
|
temp[it->second].SubNames.emplace_back(subelement);
|
|
temp[it->second].SelPoses.emplace_back(sel.x, sel.y, sel.z);
|
|
}
|
|
}
|
|
else {
|
|
if (single && !temp.empty()) {
|
|
temp.clear();
|
|
break;
|
|
}
|
|
// create a new entry
|
|
temp.emplace_back(obj);
|
|
if (subelement && *subelement) {
|
|
temp.back().SubNames.emplace_back(subelement);
|
|
temp.back().SelPoses.emplace_back(sel.x, sel.y, sel.z);
|
|
if (resolve != ResolveMode::NoResolve) {
|
|
temp.back()._SubNameSet.insert(subelement);
|
|
}
|
|
}
|
|
SortMap.insert(std::make_pair(obj, temp.size() - 1));
|
|
}
|
|
}
|
|
|
|
return temp;
|
|
}
|
|
|
|
bool SelectionSingleton::needPickedList() const
|
|
{
|
|
return _needPickedList;
|
|
}
|
|
|
|
void SelectionSingleton::enablePickedList(bool enable)
|
|
{
|
|
if (enable != _needPickedList) {
|
|
_needPickedList = enable;
|
|
_PickedList.clear();
|
|
notify(SelectionChanges(SelectionChanges::PickedListChanged));
|
|
}
|
|
}
|
|
|
|
static void notifyDocumentObjectViewProvider(const SelectionChanges& changes)
|
|
{
|
|
const auto* doc = App::GetApplication().getDocument(changes.pDocName);
|
|
if (!doc) {
|
|
return;
|
|
}
|
|
|
|
const auto* obj = doc->getObject(changes.pObjectName);
|
|
if (!obj) {
|
|
return;
|
|
}
|
|
|
|
auto* vp = Application::Instance->getViewProvider(obj);
|
|
if (!vp) {
|
|
return;
|
|
}
|
|
|
|
vp->onSelectionChanged(changes);
|
|
}
|
|
|
|
void SelectionSingleton::notify(SelectionChanges&& Chng)
|
|
{
|
|
if (Notifying) {
|
|
NotificationQueue.push_back(std::move(Chng));
|
|
return;
|
|
}
|
|
Base::FlagToggler<bool> flag(Notifying);
|
|
NotificationQueue.push_back(std::move(Chng));
|
|
while (!NotificationQueue.empty()) {
|
|
const auto& msg = NotificationQueue.front();
|
|
bool notify = false;
|
|
switch (msg.Type) {
|
|
case SelectionChanges::AddSelection:
|
|
notify = isSelected(msg.pDocName, msg.pObjectName, msg.pSubName, ResolveMode::NoResolve);
|
|
break;
|
|
case SelectionChanges::RmvSelection:
|
|
notify = !isSelected(msg.pDocName, msg.pObjectName, msg.pSubName, ResolveMode::NoResolve);
|
|
break;
|
|
case SelectionChanges::SetPreselect:
|
|
notify = CurrentPreselection.Type == SelectionChanges::SetPreselect
|
|
&& CurrentPreselection.Object == msg.Object;
|
|
break;
|
|
case SelectionChanges::RmvPreselect:
|
|
notify = CurrentPreselection.Type == SelectionChanges::ClrSelection;
|
|
break;
|
|
default:
|
|
notify = true;
|
|
}
|
|
if (notify) {
|
|
// Notify the view provider of the object.
|
|
notifyDocumentObjectViewProvider(msg);
|
|
|
|
Notify(msg);
|
|
try {
|
|
signalSelectionChanged(msg);
|
|
}
|
|
catch (const boost::exception&) {
|
|
// reported by code analyzers
|
|
Base::Console().warning("notify: Unexpected boost exception\n");
|
|
}
|
|
}
|
|
NotificationQueue.pop_front();
|
|
}
|
|
}
|
|
|
|
bool SelectionSingleton::hasPickedList() const
|
|
{
|
|
return !_PickedList.empty();
|
|
}
|
|
|
|
int SelectionSingleton::getAsPropertyLinkSubList(App::PropertyLinkSubList& prop) const
|
|
{
|
|
std::vector<Gui::SelectionObject> sel = this->getSelectionEx();
|
|
std::vector<App::DocumentObject*> objs;
|
|
objs.reserve(sel.size() * 2);
|
|
std::vector<std::string> subs;
|
|
subs.reserve(sel.size() * 2);
|
|
for (auto& selitem : sel) {
|
|
App::DocumentObject* obj = selitem.getObject();
|
|
const std::vector<std::string>& subnames = selitem.getSubNames();
|
|
|
|
// whole object is selected
|
|
if (subnames.empty()) {
|
|
objs.push_back(obj);
|
|
subs.emplace_back();
|
|
}
|
|
else {
|
|
for (const auto& subname : subnames) {
|
|
objs.push_back(obj);
|
|
subs.push_back(subname);
|
|
}
|
|
}
|
|
}
|
|
assert(objs.size() == subs.size());
|
|
prop.setValues(objs, subs);
|
|
return objs.size();
|
|
}
|
|
|
|
App::DocumentObject* SelectionSingleton::getObjectOfType(
|
|
_SelObj& sel,
|
|
Base::Type typeId,
|
|
ResolveMode resolve,
|
|
const char** subelement
|
|
)
|
|
{
|
|
auto obj = sel.pObject;
|
|
if (!obj || !obj->isAttachedToDocument()) {
|
|
return nullptr;
|
|
}
|
|
const char* subname = sel.SubName.c_str();
|
|
if (resolve != ResolveMode::NoResolve) {
|
|
obj = sel.pResolvedObject;
|
|
if (resolve == ResolveMode::NewStyleElement && !sel.elementName.newName.empty()) {
|
|
subname = sel.elementName.newName.c_str();
|
|
}
|
|
else {
|
|
subname = sel.elementName.oldName.c_str();
|
|
}
|
|
}
|
|
|
|
if (!obj) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (!obj->isDerivedFrom(typeId)
|
|
&& (resolve != ResolveMode::FollowLink || !obj->getLinkedObject(true)->isDerivedFrom(typeId))) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (subelement) {
|
|
*subelement = subname;
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
vector<App::DocumentObject*> SelectionSingleton::getObjectsOfType(
|
|
const Base::Type& typeId,
|
|
const char* pDocName,
|
|
ResolveMode resolve
|
|
) const
|
|
{
|
|
std::vector<App::DocumentObject*> temp;
|
|
|
|
App::Document* pcDoc = nullptr;
|
|
if (!pDocName || strcmp(pDocName, "*") != 0) {
|
|
pcDoc = getDocument(pDocName);
|
|
if (!pcDoc) {
|
|
return temp;
|
|
}
|
|
}
|
|
|
|
std::set<App::DocumentObject*> objs;
|
|
for (auto& sel : _SelList) {
|
|
if (pcDoc && pcDoc != sel.pDoc) {
|
|
continue;
|
|
}
|
|
App::DocumentObject* pObject = getObjectOfType(sel, typeId, resolve);
|
|
if (pObject) {
|
|
auto ret = objs.insert(pObject);
|
|
if (ret.second) {
|
|
temp.push_back(pObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
return temp;
|
|
}
|
|
|
|
std::vector<App::DocumentObject*> SelectionSingleton::getObjectsOfType(
|
|
const char* typeName,
|
|
const char* pDocName,
|
|
ResolveMode resolve
|
|
) const
|
|
{
|
|
Base::Type typeId = Base::Type::fromName(typeName);
|
|
if (typeId.isBad()) {
|
|
return {};
|
|
}
|
|
return getObjectsOfType(typeId, pDocName, resolve);
|
|
}
|
|
|
|
unsigned int SelectionSingleton::countObjectsOfType(
|
|
const Base::Type& typeId,
|
|
const char* pDocName,
|
|
ResolveMode resolve
|
|
) const
|
|
{
|
|
App::Document* pcDoc = nullptr;
|
|
if (!pDocName || strcmp(pDocName, "*") != 0) {
|
|
pcDoc = getDocument(pDocName);
|
|
if (!pcDoc) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return std::count_if(_SelList.begin(), _SelList.end(), [&](auto& sel) {
|
|
return (!pcDoc || pcDoc == sel.pDoc) && getObjectOfType(sel, typeId, resolve);
|
|
});
|
|
}
|
|
|
|
unsigned int SelectionSingleton::countObjectsOfType(
|
|
const char* typeName,
|
|
const char* pDocName,
|
|
ResolveMode resolve
|
|
) const
|
|
{
|
|
Base::Type typeId = Base::Type::fromName(typeName);
|
|
if (typeId.isBad()) {
|
|
return 0;
|
|
}
|
|
return countObjectsOfType(typeId, pDocName, resolve);
|
|
}
|
|
|
|
|
|
void SelectionSingleton::slotSelectionChanged(const SelectionChanges& msg)
|
|
{
|
|
if (msg.Type == SelectionChanges::SetPreselectSignal || msg.Type == SelectionChanges::ShowSelection
|
|
|| msg.Type == SelectionChanges::HideSelection) {
|
|
return;
|
|
}
|
|
|
|
if (!msg.Object.getSubName().empty()) {
|
|
auto pParent = msg.Object.getObject();
|
|
if (!pParent) {
|
|
return;
|
|
}
|
|
App::ElementNamePair elementName;
|
|
auto& newElementName = elementName.newName;
|
|
auto& oldElementName = elementName.oldName;
|
|
auto pObject = App::GeoFeature::resolveElement(pParent, msg.pSubName, elementName);
|
|
if (!pObject) {
|
|
return;
|
|
}
|
|
SelectionChanges msg2(
|
|
msg.Type,
|
|
pObject->getDocument()->getName(),
|
|
pObject->getNameInDocument(),
|
|
!newElementName.empty() ? newElementName.c_str() : oldElementName.c_str(),
|
|
pObject->getTypeId().getName(),
|
|
msg.x,
|
|
msg.y,
|
|
msg.z
|
|
);
|
|
|
|
try {
|
|
msg2.pOriginalMsg = &msg;
|
|
signalSelectionChanged3(msg2);
|
|
|
|
msg2.Object.setSubName(oldElementName.c_str());
|
|
msg2.pSubName = msg2.Object.getSubName().c_str();
|
|
signalSelectionChanged2(msg2);
|
|
}
|
|
catch (const boost::exception&) {
|
|
// reported by code analyzers
|
|
Base::Console().warning("slotSelectionChanged: Unexpected boost exception\n");
|
|
}
|
|
}
|
|
else {
|
|
try {
|
|
signalSelectionChanged3(msg);
|
|
signalSelectionChanged2(msg);
|
|
}
|
|
catch (const boost::exception&) {
|
|
// reported by code analyzers
|
|
Base::Console().warning("slotSelectionChanged: Unexpected boost exception\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
int SelectionSingleton::setPreselect(
|
|
const char* pDocName,
|
|
const char* pObjectName,
|
|
const char* pSubName,
|
|
float x,
|
|
float y,
|
|
float z,
|
|
SelectionChanges::MsgSource signal
|
|
)
|
|
{
|
|
if (!pDocName || !pObjectName) {
|
|
rmvPreselect();
|
|
return 0;
|
|
}
|
|
if (!pSubName) {
|
|
pSubName = "";
|
|
}
|
|
|
|
if (DocName == pDocName && FeatName == pObjectName && SubName == pSubName) {
|
|
return -1;
|
|
}
|
|
|
|
rmvPreselect();
|
|
|
|
if (ActiveGate && signal != SelectionChanges::MsgSource::Internal) {
|
|
App::Document* pDoc = getDocument(pDocName);
|
|
if (!pDoc || !pObjectName) {
|
|
return 0;
|
|
}
|
|
App::ElementNamePair elementName;
|
|
auto pObject = pDoc->getObject(pObjectName);
|
|
if (!pObject) {
|
|
return 0;
|
|
}
|
|
|
|
const char* subelement = pSubName;
|
|
if (gateResolve != ResolveMode::NoResolve) {
|
|
auto& newElementName = elementName.newName;
|
|
auto& oldElementName = elementName.oldName;
|
|
pObject = App::GeoFeature::resolveElement(pObject, pSubName, elementName);
|
|
if (!pObject) {
|
|
return 0;
|
|
}
|
|
if (gateResolve > ResolveMode::OldStyleElement) {
|
|
subelement = !newElementName.empty() ? newElementName.c_str()
|
|
: oldElementName.c_str();
|
|
}
|
|
else {
|
|
subelement = oldElementName.c_str();
|
|
}
|
|
}
|
|
if (!ActiveGate->allow(pObject->getDocument(), pObject, subelement)) {
|
|
QString msg;
|
|
if (ActiveGate->notAllowedReason.length() > 0) {
|
|
msg = QObject::tr(ActiveGate->notAllowedReason.c_str());
|
|
}
|
|
else {
|
|
msg = QCoreApplication::translate("SelectionFilter", "Not allowed:");
|
|
}
|
|
msg.append(QStringLiteral(" %1.%2.%3 ")
|
|
.arg(
|
|
QString::fromLatin1(pDocName),
|
|
QString::fromLatin1(pObjectName),
|
|
QString::fromLatin1(pSubName)
|
|
));
|
|
|
|
if (getMainWindow()) {
|
|
getMainWindow()->showMessage(msg);
|
|
Gui::MDIView* mdi = Gui::Application::Instance->activeDocument()->getActiveView();
|
|
mdi->setOverrideCursor(QCursor(Qt::ForbiddenCursor));
|
|
}
|
|
return 0;
|
|
}
|
|
Gui::MDIView* mdi = Gui::Application::Instance->activeDocument()->getActiveView();
|
|
mdi->restoreOverrideCursor();
|
|
}
|
|
|
|
DocName = pDocName;
|
|
FeatName = pObjectName;
|
|
SubName = pSubName;
|
|
hx = x;
|
|
hy = y;
|
|
hz = z;
|
|
|
|
// set up the change object
|
|
SelectionChanges Chng(
|
|
signal == SelectionChanges::MsgSource::Internal ? SelectionChanges::SetPreselectSignal
|
|
: SelectionChanges::SetPreselect,
|
|
DocName,
|
|
FeatName,
|
|
SubName,
|
|
std::string(),
|
|
x,
|
|
y,
|
|
z,
|
|
signal
|
|
);
|
|
|
|
if (Chng.Type == SelectionChanges::SetPreselect) {
|
|
CurrentPreselection = Chng;
|
|
FC_TRACE("preselect " << DocName << '#' << FeatName << '.' << SubName);
|
|
}
|
|
else {
|
|
FC_TRACE("preselect signal " << DocName << '#' << FeatName << '.' << SubName);
|
|
}
|
|
|
|
notify(Chng);
|
|
|
|
if (signal == SelectionChanges::MsgSource::Internal && !DocName.empty()) {
|
|
FC_TRACE("preselect " << DocName << '#' << FeatName << '.' << SubName);
|
|
Chng.Type = SelectionChanges::SetPreselect;
|
|
CurrentPreselection = Chng;
|
|
notify(std::move(Chng));
|
|
}
|
|
|
|
// It is possible the preselect is removed during notification
|
|
return DocName.empty() ? 0 : 1;
|
|
}
|
|
|
|
namespace Gui
|
|
{
|
|
std::array<std::pair<double, std::string>, 3> schemaTranslatePoint(
|
|
double x,
|
|
double y,
|
|
double z,
|
|
double precision
|
|
)
|
|
{
|
|
Base::Quantity mmx(Base::Quantity::MilliMetre);
|
|
mmx.setValue(fabs(x) > precision ? x : 0.0);
|
|
Base::Quantity mmy(Base::Quantity::MilliMetre);
|
|
mmy.setValue(fabs(y) > precision ? y : 0.0);
|
|
Base::Quantity mmz(Base::Quantity::MilliMetre);
|
|
mmz.setValue(fabs(z) > precision ? z : 0.0);
|
|
|
|
double xfactor, yfactor, zfactor;
|
|
std::string xunit, yunit, zunit;
|
|
|
|
Base::UnitsApi::schemaTranslate(mmx, xfactor, xunit);
|
|
Base::UnitsApi::schemaTranslate(mmy, yfactor, yunit);
|
|
Base::UnitsApi::schemaTranslate(mmz, zfactor, zunit);
|
|
|
|
double xuser = fabs(x) > precision ? x / xfactor : 0.0;
|
|
double yuser = fabs(y) > precision ? y / yfactor : 0.0;
|
|
double zuser = fabs(z) > precision ? z / zfactor : 0.0;
|
|
|
|
std::array<std::pair<double, std::string>, 3> ret
|
|
= {std::make_pair(xuser, xunit), std::make_pair(yuser, yunit), std::make_pair(zuser, zunit)};
|
|
return ret;
|
|
}
|
|
|
|
QString getPreselectionInfo(
|
|
const char* documentName,
|
|
const char* objectName,
|
|
const char* subElementName,
|
|
float x,
|
|
float y,
|
|
float z,
|
|
double precision
|
|
)
|
|
{
|
|
auto pts = schemaTranslatePoint(x, y, z, precision);
|
|
|
|
int numberDecimals = std::min(6, static_cast<int>(Base::UnitsApi::getDecimals()));
|
|
|
|
QString message = QStringLiteral("Preselected: %1.%2.%3 (%4 %5, %6 %7, %8 %9)")
|
|
.arg(QString::fromUtf8(documentName))
|
|
.arg(QString::fromUtf8(objectName))
|
|
.arg(QString::fromUtf8(subElementName))
|
|
.arg(QString::number(pts[0].first, 'f', numberDecimals))
|
|
.arg(QString::fromStdString(pts[0].second))
|
|
.arg(QString::number(pts[1].first, 'f', numberDecimals))
|
|
.arg(QString::fromStdString(pts[1].second))
|
|
.arg(QString::number(pts[2].first, 'f', numberDecimals))
|
|
.arg(QString::fromStdString(pts[2].second));
|
|
return message;
|
|
}
|
|
|
|
void printPreselectionInfo(
|
|
const char* documentName,
|
|
const char* objectName,
|
|
const char* subElementName,
|
|
float x,
|
|
float y,
|
|
float z,
|
|
double precision
|
|
)
|
|
{
|
|
if (getMainWindow()) {
|
|
QString message
|
|
= getPreselectionInfo(documentName, objectName, subElementName, x, y, z, precision);
|
|
getMainWindow()->showMessage(message);
|
|
}
|
|
}
|
|
} // namespace Gui
|
|
|
|
void SelectionSingleton::setPreselectCoord(float x, float y, float z)
|
|
{
|
|
// if nothing is in preselect ignore
|
|
if (CurrentPreselection.Object.getObjectName().empty()) {
|
|
return;
|
|
}
|
|
|
|
CurrentPreselection.x = x;
|
|
CurrentPreselection.y = y;
|
|
CurrentPreselection.z = z;
|
|
|
|
printPreselectionInfo(
|
|
CurrentPreselection.pDocName,
|
|
CurrentPreselection.pObjectName,
|
|
CurrentPreselection.pSubName,
|
|
x,
|
|
y,
|
|
z,
|
|
0.0
|
|
);
|
|
}
|
|
|
|
void SelectionSingleton::rmvPreselect(bool signal)
|
|
{
|
|
if (DocName.empty()) {
|
|
return;
|
|
}
|
|
|
|
if (signal) {
|
|
SelectionChanges Chng(SelectionChanges::RmvPreselectSignal, DocName, FeatName, SubName);
|
|
notify(std::move(Chng));
|
|
return;
|
|
}
|
|
|
|
SelectionChanges Chng(SelectionChanges::RmvPreselect, DocName, FeatName, SubName);
|
|
|
|
// reset the current preselection
|
|
CurrentPreselection = SelectionChanges();
|
|
|
|
DocName = "";
|
|
FeatName = "";
|
|
SubName = "";
|
|
hx = 0;
|
|
hy = 0;
|
|
hz = 0;
|
|
|
|
if (ActiveGate && getMainWindow()) {
|
|
Gui::MDIView* mdi = Gui::Application::Instance->activeDocument()->getActiveView();
|
|
mdi->restoreOverrideCursor();
|
|
}
|
|
|
|
FC_TRACE("rmv preselect");
|
|
|
|
// notify observing objects
|
|
notify(std::move(Chng));
|
|
}
|
|
|
|
const SelectionChanges& SelectionSingleton::getPreselection() const
|
|
{
|
|
return CurrentPreselection;
|
|
}
|
|
|
|
// add a SelectionGate to control what is selectable
|
|
void SelectionSingleton::addSelectionGate(Gui::SelectionGate* gate, ResolveMode resolve)
|
|
{
|
|
if (ActiveGate) {
|
|
rmvSelectionGate();
|
|
}
|
|
|
|
ActiveGate = gate;
|
|
gateResolve = resolve;
|
|
}
|
|
|
|
// remove the active SelectionGate
|
|
void SelectionSingleton::rmvSelectionGate()
|
|
{
|
|
if (ActiveGate) {
|
|
delete ActiveGate;
|
|
ActiveGate = nullptr;
|
|
|
|
Gui::Document* doc = Gui::Application::Instance->activeDocument();
|
|
if (doc) {
|
|
// if a document is about to be closed it has no MDI view any more
|
|
Gui::MDIView* mdi = doc->getActiveView();
|
|
if (mdi) {
|
|
mdi->restoreOverrideCursor();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
App::Document* SelectionSingleton::getDocument(const char* pDocName) const
|
|
{
|
|
if (!Base::Tools::isNullOrEmpty(pDocName)) {
|
|
return App::GetApplication().getDocument(pDocName);
|
|
}
|
|
else {
|
|
return App::GetApplication().getActiveDocument();
|
|
}
|
|
}
|
|
|
|
int SelectionSingleton::disableCommandLog()
|
|
{
|
|
if (!logDisabled) {
|
|
logHasSelection = hasSelection();
|
|
}
|
|
return ++logDisabled;
|
|
}
|
|
|
|
int SelectionSingleton::enableCommandLog(bool silent)
|
|
{
|
|
--logDisabled;
|
|
if (!logDisabled && !silent) {
|
|
auto manager = Application::Instance->macroManager();
|
|
if (!hasSelection()) {
|
|
if (logHasSelection) {
|
|
manager->addLine(MacroManager::Cmt, "Gui.Selection.clearSelection()");
|
|
}
|
|
}
|
|
else {
|
|
for (auto& sel : _SelList) {
|
|
sel.log();
|
|
}
|
|
}
|
|
}
|
|
return logDisabled;
|
|
}
|
|
|
|
void SelectionSingleton::_SelObj::log(bool remove, bool clearPreselect)
|
|
{
|
|
if (logged && !remove) {
|
|
return;
|
|
}
|
|
logged = true;
|
|
std::ostringstream ss;
|
|
ss << "Gui.Selection." << (remove ? "removeSelection" : "addSelection") << "('" << DocName
|
|
<< "','" << FeatName << "'";
|
|
if (!SubName.empty()) {
|
|
if (!elementName.oldName.empty() && !elementName.newName.empty()) {
|
|
ss << ",'" << SubName.substr(0, SubName.size() - elementName.newName.size())
|
|
<< elementName.oldName << "'";
|
|
}
|
|
else {
|
|
ss << ",'" << SubName << "'";
|
|
}
|
|
}
|
|
if (!remove && (x || y || z || !clearPreselect)) {
|
|
if (SubName.empty()) {
|
|
ss << ",''";
|
|
}
|
|
ss << ',' << x << ',' << y << ',' << z;
|
|
if (!clearPreselect) {
|
|
ss << ",False";
|
|
}
|
|
}
|
|
ss << ')';
|
|
Application::Instance->macroManager()->addLine(MacroManager::Cmt, ss.str().c_str());
|
|
}
|
|
|
|
bool SelectionSingleton::addSelection(
|
|
const char* pDocName,
|
|
const char* pObjectName,
|
|
const char* pSubName,
|
|
float x,
|
|
float y,
|
|
float z,
|
|
const std::vector<SelObj>* pickedList,
|
|
bool clearPreselect
|
|
)
|
|
{
|
|
if (pickedList) {
|
|
_PickedList.clear();
|
|
for (const auto& sel : *pickedList) {
|
|
_PickedList.emplace_back();
|
|
auto& s = _PickedList.back();
|
|
s.DocName = sel.DocName;
|
|
s.FeatName = sel.FeatName;
|
|
s.SubName = sel.SubName;
|
|
s.TypeName = sel.TypeName;
|
|
s.pObject = sel.pObject;
|
|
s.pDoc = sel.pDoc;
|
|
s.x = sel.x;
|
|
s.y = sel.y;
|
|
s.z = sel.z;
|
|
}
|
|
notify(SelectionChanges(SelectionChanges::PickedListChanged));
|
|
}
|
|
|
|
_SelObj temp;
|
|
int ret = checkSelection(pDocName, pObjectName, pSubName, ResolveMode::NoResolve, temp);
|
|
if (ret != 0) {
|
|
return false;
|
|
}
|
|
|
|
temp.x = x;
|
|
temp.y = y;
|
|
temp.z = z;
|
|
|
|
// check for a Selection Gate
|
|
if (ActiveGate) {
|
|
const char* subelement = nullptr;
|
|
auto pObject
|
|
= getObjectOfType(temp, App::DocumentObject::getClassTypeId(), gateResolve, &subelement);
|
|
if (!ActiveGate->allow(pObject ? pObject->getDocument() : temp.pDoc, pObject, subelement)) {
|
|
if (getMainWindow()) {
|
|
QString msg;
|
|
if (ActiveGate->notAllowedReason.length() > 0) {
|
|
msg = QObject::tr(ActiveGate->notAllowedReason.c_str());
|
|
}
|
|
else {
|
|
msg = QCoreApplication::translate(
|
|
"SelectionFilter",
|
|
"Selection not allowed by filter"
|
|
);
|
|
}
|
|
getMainWindow()->showMessage(msg);
|
|
Gui::MDIView* mdi = Gui::Application::Instance->activeDocument()->getActiveView();
|
|
mdi->setOverrideCursor(Qt::ForbiddenCursor);
|
|
}
|
|
ActiveGate->notAllowedReason.clear();
|
|
QApplication::beep();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!logDisabled) {
|
|
temp.log(false, clearPreselect);
|
|
}
|
|
|
|
_SelList.push_back(temp);
|
|
_SelStackForward.clear();
|
|
|
|
if (clearPreselect) {
|
|
rmvPreselect();
|
|
}
|
|
|
|
SelectionChanges Chng(
|
|
SelectionChanges::AddSelection,
|
|
temp.DocName,
|
|
temp.FeatName,
|
|
temp.SubName,
|
|
temp.TypeName,
|
|
x,
|
|
y,
|
|
z
|
|
);
|
|
|
|
FC_LOG(
|
|
"Add Selection " << Chng.pDocName << '#' << Chng.pObjectName << '.' << Chng.pSubName << " ("
|
|
<< x << ", " << y << ", " << z << ')'
|
|
);
|
|
|
|
notify(std::move(Chng));
|
|
|
|
getMainWindow()->updateActions();
|
|
|
|
rmvPreselect(true);
|
|
|
|
// There is a possibility that some observer removes or clears selection
|
|
// inside signal handler, hence the check here
|
|
return isSelected(temp.DocName.c_str(), temp.FeatName.c_str(), temp.SubName.c_str());
|
|
}
|
|
|
|
void SelectionSingleton::selStackPush(bool clearForward, bool overwrite)
|
|
{
|
|
static int stackSize;
|
|
if (!stackSize) {
|
|
stackSize = App::GetApplication()
|
|
.GetParameterGroupByPath("User parameter:BaseApp/Preferences/View")
|
|
->GetInt("SelectionStackSize", 100);
|
|
}
|
|
if (clearForward) {
|
|
_SelStackForward.clear();
|
|
}
|
|
if (_SelList.empty()) {
|
|
return;
|
|
}
|
|
if ((int)_SelStackBack.size() >= stackSize) {
|
|
_SelStackBack.pop_front();
|
|
}
|
|
SelStackItem item;
|
|
for (auto& sel : _SelList) {
|
|
item.emplace(sel.DocName.c_str(), sel.FeatName.c_str(), sel.SubName.c_str());
|
|
}
|
|
if (!_SelStackBack.empty() && _SelStackBack.back() == item) {
|
|
return;
|
|
}
|
|
if (!overwrite || _SelStackBack.empty()) {
|
|
_SelStackBack.emplace_back();
|
|
}
|
|
_SelStackBack.back() = std::move(item);
|
|
}
|
|
|
|
void SelectionSingleton::selStackGoBack(int count)
|
|
{
|
|
if ((int)_SelStackBack.size() < count) {
|
|
count = _SelStackBack.size();
|
|
}
|
|
if (count <= 0) {
|
|
return;
|
|
}
|
|
if (!_SelList.empty()) {
|
|
selStackPush(false, true);
|
|
clearCompleteSelection();
|
|
}
|
|
else {
|
|
--count;
|
|
}
|
|
for (int i = 0; i < count; ++i) {
|
|
_SelStackForward.push_front(std::move(_SelStackBack.back()));
|
|
_SelStackBack.pop_back();
|
|
}
|
|
std::deque<SelStackItem> tmpStack;
|
|
_SelStackForward.swap(tmpStack);
|
|
while (!_SelStackBack.empty()) {
|
|
bool found = false;
|
|
for (auto& sobjT : _SelStackBack.back()) {
|
|
if (sobjT.getSubObject()) {
|
|
addSelection(
|
|
sobjT.getDocumentName().c_str(),
|
|
sobjT.getObjectName().c_str(),
|
|
sobjT.getSubName().c_str()
|
|
);
|
|
found = true;
|
|
}
|
|
}
|
|
if (found) {
|
|
break;
|
|
}
|
|
tmpStack.push_front(std::move(_SelStackBack.back()));
|
|
_SelStackBack.pop_back();
|
|
}
|
|
_SelStackForward = std::move(tmpStack);
|
|
getMainWindow()->updateActions();
|
|
}
|
|
|
|
void SelectionSingleton::selStackGoForward(int count)
|
|
{
|
|
if ((int)_SelStackForward.size() < count) {
|
|
count = _SelStackForward.size();
|
|
}
|
|
if (count <= 0) {
|
|
return;
|
|
}
|
|
if (!_SelList.empty()) {
|
|
selStackPush(false, true);
|
|
clearCompleteSelection();
|
|
}
|
|
for (int i = 0; i < count; ++i) {
|
|
_SelStackBack.push_back(_SelStackForward.front());
|
|
_SelStackForward.pop_front();
|
|
}
|
|
std::deque<SelStackItem> tmpStack;
|
|
_SelStackForward.swap(tmpStack);
|
|
while (true) {
|
|
bool found = false;
|
|
for (auto& sobjT : _SelStackBack.back()) {
|
|
if (sobjT.getSubObject()) {
|
|
addSelection(
|
|
sobjT.getDocumentName().c_str(),
|
|
sobjT.getObjectName().c_str(),
|
|
sobjT.getSubName().c_str()
|
|
);
|
|
found = true;
|
|
}
|
|
}
|
|
if (found || tmpStack.empty()) {
|
|
break;
|
|
}
|
|
_SelStackBack.push_back(tmpStack.front());
|
|
tmpStack.pop_front();
|
|
}
|
|
_SelStackForward = std::move(tmpStack);
|
|
getMainWindow()->updateActions();
|
|
}
|
|
|
|
std::vector<SelectionObject> SelectionSingleton::selStackGet(
|
|
const char* pDocName,
|
|
ResolveMode resolve,
|
|
int index
|
|
) const
|
|
{
|
|
const SelStackItem* item = nullptr;
|
|
if (index >= 0) {
|
|
if (index >= (int)_SelStackBack.size()) {
|
|
return {};
|
|
}
|
|
item = &_SelStackBack[_SelStackBack.size() - 1 - index];
|
|
}
|
|
else {
|
|
index = -index - 1;
|
|
if (index >= (int)_SelStackForward.size()) {
|
|
return {};
|
|
}
|
|
item = &_SelStackBack[_SelStackForward.size() - 1 - index];
|
|
}
|
|
|
|
std::list<_SelObj> selList;
|
|
for (auto& sobjT : *item) {
|
|
_SelObj sel;
|
|
if (checkSelection(
|
|
sobjT.getDocumentName().c_str(),
|
|
sobjT.getObjectName().c_str(),
|
|
sobjT.getSubName().c_str(),
|
|
ResolveMode::NoResolve,
|
|
sel,
|
|
&selList
|
|
)
|
|
== 0) {
|
|
selList.push_back(sel);
|
|
}
|
|
}
|
|
|
|
return getObjectList(pDocName, App::DocumentObject::getClassTypeId(), selList, resolve);
|
|
}
|
|
|
|
bool SelectionSingleton::addSelections(
|
|
const char* pDocName,
|
|
const char* pObjectName,
|
|
const std::vector<std::string>& pSubNames
|
|
)
|
|
{
|
|
if (!_PickedList.empty()) {
|
|
_PickedList.clear();
|
|
notify(SelectionChanges(SelectionChanges::PickedListChanged));
|
|
}
|
|
|
|
bool update = false;
|
|
for (const auto& pSubName : pSubNames) {
|
|
_SelObj temp;
|
|
int ret = checkSelection(pDocName, pObjectName, pSubName.c_str(), ResolveMode::NoResolve, temp);
|
|
if (ret != 0) {
|
|
continue;
|
|
}
|
|
|
|
temp.x = 0;
|
|
temp.y = 0;
|
|
temp.z = 0;
|
|
|
|
_SelList.push_back(temp);
|
|
_SelStackForward.clear();
|
|
|
|
SelectionChanges Chng(
|
|
SelectionChanges::AddSelection,
|
|
temp.DocName,
|
|
temp.FeatName,
|
|
temp.SubName,
|
|
temp.TypeName
|
|
);
|
|
|
|
FC_LOG("Add Selection " << Chng.pDocName << '#' << Chng.pObjectName << '.' << Chng.pSubName);
|
|
|
|
notify(std::move(Chng));
|
|
update = true;
|
|
}
|
|
|
|
if (update) {
|
|
getMainWindow()->updateActions();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SelectionSingleton::updateSelection(
|
|
bool show,
|
|
const char* pDocName,
|
|
const char* pObjectName,
|
|
const char* pSubName
|
|
)
|
|
{
|
|
if (!pDocName || !pObjectName) {
|
|
return false;
|
|
}
|
|
if (!pSubName) {
|
|
pSubName = "";
|
|
}
|
|
if (DocName == pDocName && FeatName == pObjectName && SubName == pSubName) {
|
|
if (show) {
|
|
FC_TRACE("preselect signal");
|
|
notify(SelectionChanges(SelectionChanges::SetPreselectSignal, DocName, FeatName, SubName));
|
|
}
|
|
else {
|
|
rmvPreselect();
|
|
}
|
|
}
|
|
auto pDoc = getDocument(pDocName);
|
|
if (!pDoc) {
|
|
return false;
|
|
}
|
|
auto pObject = pDoc->getObject(pObjectName);
|
|
if (!pObject) {
|
|
return false;
|
|
}
|
|
if (!isSelected(pObject, pSubName, ResolveMode::NoResolve)) {
|
|
return false;
|
|
}
|
|
|
|
SelectionChanges Chng(
|
|
show ? SelectionChanges::ShowSelection : SelectionChanges::HideSelection,
|
|
pDocName,
|
|
pObjectName,
|
|
pSubName,
|
|
pObject->getTypeId().getName()
|
|
);
|
|
|
|
FC_LOG("Update Selection " << Chng.pDocName << '#' << Chng.pObjectName << '.' << Chng.pSubName);
|
|
|
|
notify(std::move(Chng));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool SelectionSingleton::addSelection(const SelectionObject& obj, bool clearPreselect)
|
|
{
|
|
const std::vector<std::string>& subNames = obj.getSubNames();
|
|
const std::vector<Base::Vector3d> points = obj.getPickedPoints();
|
|
if (!subNames.empty() && subNames.size() == points.size()) {
|
|
bool ok = true;
|
|
for (std::size_t i = 0; i < subNames.size(); i++) {
|
|
const std::string& name = subNames[i];
|
|
const Base::Vector3d& pnt = points[i];
|
|
ok &= addSelection(
|
|
obj.getDocName(),
|
|
obj.getFeatName(),
|
|
name.c_str(),
|
|
static_cast<float>(pnt.x),
|
|
static_cast<float>(pnt.y),
|
|
static_cast<float>(pnt.z),
|
|
nullptr,
|
|
clearPreselect
|
|
);
|
|
}
|
|
return ok;
|
|
}
|
|
else if (!subNames.empty()) {
|
|
bool ok = true;
|
|
for (const std::string& name : subNames) {
|
|
ok &= addSelection(obj.getDocName(), obj.getFeatName(), name.c_str());
|
|
}
|
|
return ok;
|
|
}
|
|
else {
|
|
return addSelection(obj.getDocName(), obj.getFeatName());
|
|
}
|
|
}
|
|
|
|
|
|
void SelectionSingleton::rmvSelection(
|
|
const char* pDocName,
|
|
const char* pObjectName,
|
|
const char* pSubName,
|
|
const std::vector<SelObj>* pickedList
|
|
)
|
|
{
|
|
if (pickedList) {
|
|
_PickedList.clear();
|
|
for (const auto& sel : *pickedList) {
|
|
_PickedList.emplace_back();
|
|
auto& s = _PickedList.back();
|
|
s.DocName = sel.DocName;
|
|
s.FeatName = sel.FeatName;
|
|
s.SubName = sel.SubName;
|
|
s.TypeName = sel.TypeName;
|
|
s.pObject = sel.pObject;
|
|
s.pDoc = sel.pDoc;
|
|
s.x = sel.x;
|
|
s.y = sel.y;
|
|
s.z = sel.z;
|
|
}
|
|
notify(SelectionChanges(SelectionChanges::PickedListChanged));
|
|
}
|
|
|
|
if (!pDocName) {
|
|
return;
|
|
}
|
|
|
|
_SelObj temp;
|
|
int ret = checkSelection(pDocName, pObjectName, pSubName, ResolveMode::NoResolve, temp);
|
|
if (ret < 0) {
|
|
return;
|
|
}
|
|
|
|
std::vector<SelectionChanges> changes;
|
|
for (auto It = _SelList.begin(), ItNext = It; It != _SelList.end(); It = ItNext) {
|
|
++ItNext;
|
|
if (It->DocName != temp.DocName || It->FeatName != temp.FeatName) {
|
|
continue;
|
|
}
|
|
// if no subname is specified, remove all subobjects of the matching object
|
|
if (!temp.SubName.empty()) {
|
|
// otherwise, match subojects with common prefix, separated by '.'
|
|
if (!boost::starts_with(It->SubName, temp.SubName)
|
|
|| (It->SubName.length() != temp.SubName.length()
|
|
&& It->SubName[temp.SubName.length() - 1] != '.')) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
It->log(true);
|
|
|
|
changes.emplace_back(
|
|
SelectionChanges::RmvSelection,
|
|
It->DocName,
|
|
It->FeatName,
|
|
It->SubName,
|
|
It->TypeName
|
|
);
|
|
|
|
// destroy the _SelObj item
|
|
_SelList.erase(It);
|
|
}
|
|
|
|
// NOTE: It can happen that there are nested calls of rmvSelection()
|
|
// so that it's not safe to invoke the notifications inside the loop
|
|
// as this can invalidate the iterators and thus leads to undefined
|
|
// behaviour.
|
|
// So, the notification is done after the loop, see also #0003469
|
|
if (!changes.empty()) {
|
|
for (auto& Chng : changes) {
|
|
FC_LOG(
|
|
"Rmv Selection " << Chng.pDocName << '#' << Chng.pObjectName << '.' << Chng.pSubName
|
|
);
|
|
notify(std::move(Chng));
|
|
}
|
|
getMainWindow()->updateActions();
|
|
}
|
|
}
|
|
|
|
struct SelInfo
|
|
{
|
|
std::string DocName;
|
|
std::string FeatName;
|
|
std::string SubName;
|
|
SelInfo(const std::string& docName, const std::string& featName, const std::string& subName)
|
|
: DocName(docName)
|
|
, FeatName(featName)
|
|
, SubName(subName)
|
|
{}
|
|
};
|
|
|
|
void SelectionSingleton::setVisible(VisibleState vis)
|
|
{
|
|
std::set<std::pair<App::DocumentObject*, App::DocumentObject*>> filter;
|
|
int visible;
|
|
switch (vis) {
|
|
case VisShow:
|
|
visible = 1;
|
|
break;
|
|
case VisToggle:
|
|
visible = -1;
|
|
break;
|
|
default:
|
|
visible = 0;
|
|
}
|
|
|
|
// Copy the selection in case it changes during this function
|
|
std::vector<SelInfo> sels;
|
|
sels.reserve(_SelList.size());
|
|
for (auto& sel : _SelList) {
|
|
if (sel.DocName.empty() || sel.FeatName.empty() || !sel.pObject) {
|
|
continue;
|
|
}
|
|
sels.emplace_back(sel.DocName, sel.FeatName, sel.SubName);
|
|
}
|
|
|
|
for (auto& sel : sels) {
|
|
App::Document* doc = App::GetApplication().getDocument(sel.DocName.c_str());
|
|
if (!doc) {
|
|
continue;
|
|
}
|
|
App::DocumentObject* obj = doc->getObject(sel.FeatName.c_str());
|
|
if (!obj) {
|
|
continue;
|
|
}
|
|
|
|
// get parent object
|
|
App::DocumentObject* parent = nullptr;
|
|
std::string elementName;
|
|
obj = obj->resolve(sel.SubName.c_str(), &parent, &elementName);
|
|
if (!obj || !obj->isAttachedToDocument() || (parent && !parent->isAttachedToDocument())) {
|
|
continue;
|
|
}
|
|
// try call parent object's setElementVisible
|
|
if (parent) {
|
|
// prevent setting the same object visibility more than once
|
|
if (!filter.insert(std::make_pair(obj, parent)).second) {
|
|
continue;
|
|
}
|
|
int visElement = parent->isElementVisible(elementName.c_str());
|
|
if (visElement >= 0) {
|
|
if (visElement > 0) {
|
|
visElement = 1;
|
|
}
|
|
if (visible >= 0) {
|
|
if (visElement == visible) {
|
|
continue;
|
|
}
|
|
visElement = visible;
|
|
}
|
|
else {
|
|
visElement = !visElement;
|
|
}
|
|
|
|
if (!visElement) {
|
|
updateSelection(
|
|
false,
|
|
sel.DocName.c_str(),
|
|
sel.FeatName.c_str(),
|
|
sel.SubName.c_str()
|
|
);
|
|
}
|
|
parent->setElementVisible(elementName.c_str(), visElement ? true : false);
|
|
if (visElement) {
|
|
updateSelection(true, sel.DocName.c_str(), sel.FeatName.c_str(), sel.SubName.c_str());
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Fall back to direct object visibility setting
|
|
}
|
|
if (!filter.insert(std::make_pair(obj, static_cast<App::DocumentObject*>(nullptr))).second) {
|
|
continue;
|
|
}
|
|
|
|
auto vp = Application::Instance->getViewProvider(obj);
|
|
|
|
if (vp) {
|
|
bool visObject;
|
|
if (visible >= 0) {
|
|
visObject = visible ? true : false;
|
|
}
|
|
else {
|
|
visObject = !vp->isShow();
|
|
}
|
|
|
|
if (visObject) {
|
|
vp->show();
|
|
updateSelection(
|
|
visObject,
|
|
sel.DocName.c_str(),
|
|
sel.FeatName.c_str(),
|
|
sel.SubName.c_str()
|
|
);
|
|
}
|
|
else {
|
|
updateSelection(
|
|
visObject,
|
|
sel.DocName.c_str(),
|
|
sel.FeatName.c_str(),
|
|
sel.SubName.c_str()
|
|
);
|
|
vp->hide();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SelectionSingleton::setSelection(const char* pDocName, const std::vector<App::DocumentObject*>& sel)
|
|
{
|
|
App::Document* pcDoc;
|
|
pcDoc = getDocument(pDocName);
|
|
if (!pcDoc) {
|
|
return;
|
|
}
|
|
|
|
if (!_PickedList.empty()) {
|
|
_PickedList.clear();
|
|
notify(SelectionChanges(SelectionChanges::PickedListChanged));
|
|
}
|
|
|
|
bool touched = false;
|
|
for (auto obj : sel) {
|
|
if (!obj || !obj->isAttachedToDocument()) {
|
|
continue;
|
|
}
|
|
_SelObj temp;
|
|
int ret
|
|
= checkSelection(pDocName, obj->getNameInDocument(), nullptr, ResolveMode::NoResolve, temp);
|
|
if (ret != 0) {
|
|
continue;
|
|
}
|
|
touched = true;
|
|
_SelList.push_back(temp);
|
|
}
|
|
|
|
if (touched) {
|
|
_SelStackForward.clear();
|
|
notify(SelectionChanges(SelectionChanges::SetSelection, pDocName));
|
|
getMainWindow()->updateActions();
|
|
}
|
|
}
|
|
|
|
void SelectionSingleton::clearSelection(const char* pDocName, bool clearPreSelect)
|
|
{
|
|
// Because the introduction of external editing, it is best to make
|
|
// clearSelection(0) behave as clearCompleteSelection(), which is the same
|
|
// behavior of python Selection.clearSelection(None)
|
|
if (!pDocName || !pDocName[0] || strcmp(pDocName, "*") == 0) {
|
|
clearCompleteSelection(clearPreSelect);
|
|
return;
|
|
}
|
|
|
|
if (!_PickedList.empty()) {
|
|
_PickedList.clear();
|
|
notify(SelectionChanges(SelectionChanges::PickedListChanged));
|
|
}
|
|
|
|
App::Document* pDoc;
|
|
pDoc = getDocument(pDocName);
|
|
if (pDoc) {
|
|
std::string docName = pDocName;
|
|
if (clearPreSelect && DocName == docName) {
|
|
rmvPreselect();
|
|
}
|
|
|
|
bool touched = false;
|
|
for (auto it = _SelList.begin(); it != _SelList.end();) {
|
|
if (it->DocName == docName) {
|
|
touched = true;
|
|
it = _SelList.erase(it);
|
|
}
|
|
else {
|
|
++it;
|
|
}
|
|
}
|
|
|
|
if (!touched) {
|
|
return;
|
|
}
|
|
|
|
if (!logDisabled) {
|
|
std::ostringstream ss;
|
|
ss << "Gui.Selection.clearSelection('" << docName << "'";
|
|
if (!clearPreSelect) {
|
|
ss << ", False";
|
|
}
|
|
ss << ')';
|
|
Application::Instance->macroManager()->addLine(MacroManager::Cmt, ss.str().c_str());
|
|
}
|
|
|
|
notify(SelectionChanges(SelectionChanges::ClrSelection, docName.c_str()));
|
|
|
|
getMainWindow()->updateActions();
|
|
}
|
|
}
|
|
|
|
void SelectionSingleton::clearCompleteSelection(bool clearPreSelect)
|
|
{
|
|
if (!_PickedList.empty()) {
|
|
_PickedList.clear();
|
|
notify(SelectionChanges(SelectionChanges::PickedListChanged));
|
|
}
|
|
|
|
if (clearPreSelect) {
|
|
rmvPreselect();
|
|
}
|
|
|
|
if (_SelList.empty()) {
|
|
return;
|
|
}
|
|
|
|
if (!logDisabled) {
|
|
Application::Instance->macroManager()->addLine(
|
|
MacroManager::Cmt,
|
|
clearPreSelect ? "Gui.Selection.clearSelection()" : "Gui.Selection.clearSelection(False)"
|
|
);
|
|
}
|
|
|
|
// Send the clear selection notification to all view providers associated with the
|
|
// objects being deselected.
|
|
|
|
std::set<ViewProvider*> viewProviders;
|
|
for (_SelObj& sel : _SelList) {
|
|
if (auto vp = Application::Instance->getViewProvider(sel.pObject)) {
|
|
viewProviders.insert(vp);
|
|
}
|
|
}
|
|
|
|
for (auto& vp : viewProviders) {
|
|
SelectionChanges Chng(SelectionChanges::ClrSelection);
|
|
vp->onSelectionChanged(Chng);
|
|
}
|
|
|
|
_SelList.clear();
|
|
|
|
SelectionChanges Chng(SelectionChanges::ClrSelection);
|
|
|
|
FC_LOG("Clear selection");
|
|
|
|
notify(std::move(Chng));
|
|
getMainWindow()->updateActions();
|
|
}
|
|
|
|
bool SelectionSingleton::isSelected(
|
|
const char* pDocName,
|
|
const char* pObjectName,
|
|
const char* pSubName,
|
|
ResolveMode resolve
|
|
) const
|
|
{
|
|
_SelObj sel;
|
|
return checkSelection(pDocName, pObjectName, pSubName, resolve, sel, &_SelList) > 0;
|
|
}
|
|
|
|
bool SelectionSingleton::isSelected(
|
|
App::DocumentObject* pObject,
|
|
const char* pSubName,
|
|
ResolveMode resolve
|
|
) const
|
|
{
|
|
if (!pObject || !pObject->isAttachedToDocument() || !pObject->getDocument()) {
|
|
return false;
|
|
}
|
|
_SelObj sel;
|
|
return checkSelection(
|
|
pObject->getDocument()->getName(),
|
|
pObject->getNameInDocument(),
|
|
pSubName,
|
|
resolve,
|
|
sel,
|
|
&_SelList
|
|
)
|
|
> 0;
|
|
}
|
|
|
|
int SelectionSingleton::checkSelection(
|
|
const char* pDocName,
|
|
const char* pObjectName,
|
|
const char* pSubName,
|
|
ResolveMode resolve,
|
|
_SelObj& sel,
|
|
const std::list<_SelObj>* selList
|
|
) const
|
|
{
|
|
sel.pDoc = getDocument(pDocName);
|
|
if (!sel.pDoc) {
|
|
if (!selList) {
|
|
FC_ERR("Cannot find document");
|
|
}
|
|
return -1;
|
|
}
|
|
pDocName = sel.pDoc->getName();
|
|
sel.DocName = pDocName;
|
|
|
|
if (pObjectName) {
|
|
sel.pObject = sel.pDoc->getObject(pObjectName);
|
|
}
|
|
else {
|
|
sel.pObject = nullptr;
|
|
}
|
|
if (!sel.pObject) {
|
|
if (!selList) {
|
|
FC_ERR("Object not found");
|
|
}
|
|
return -1;
|
|
}
|
|
if (sel.pObject->testStatus(App::ObjectStatus::Remove)) {
|
|
return -1;
|
|
}
|
|
if (pSubName) {
|
|
sel.SubName = pSubName;
|
|
}
|
|
if (resolve == ResolveMode::NoResolve) {
|
|
TreeWidget::checkTopParent(sel.pObject, sel.SubName);
|
|
}
|
|
pSubName = !sel.SubName.empty() ? sel.SubName.c_str() : nullptr;
|
|
sel.FeatName = sel.pObject->getNameInDocument();
|
|
sel.TypeName = sel.pObject->getTypeId().getName();
|
|
const char* element = nullptr;
|
|
sel.pResolvedObject = App::GeoFeature::resolveElement(
|
|
sel.pObject,
|
|
pSubName,
|
|
sel.elementName,
|
|
false,
|
|
App::GeoFeature::Normal,
|
|
nullptr,
|
|
&element
|
|
);
|
|
if (!sel.pResolvedObject) {
|
|
if (!selList) {
|
|
FC_ERR(
|
|
"Sub-object " << sel.DocName << '#' << sel.FeatName << '.' << sel.SubName << " not found"
|
|
);
|
|
}
|
|
return -1;
|
|
}
|
|
if (sel.pResolvedObject->testStatus(App::ObjectStatus::Remove)) {
|
|
return -1;
|
|
}
|
|
std::string subname;
|
|
std::string prefix;
|
|
if (pSubName && element) {
|
|
prefix = std::string(pSubName, element - pSubName);
|
|
if (!sel.elementName.newName.empty()) {
|
|
// make sure the selected sub name is a new style if available
|
|
subname = prefix + sel.elementName.newName;
|
|
pSubName = subname.c_str();
|
|
sel.SubName = subname;
|
|
}
|
|
}
|
|
if (!selList) {
|
|
selList = &_SelList;
|
|
}
|
|
|
|
if (!pSubName) {
|
|
pSubName = "";
|
|
}
|
|
|
|
for (auto& s : *selList) {
|
|
if (s.DocName == pDocName && s.FeatName == sel.FeatName) {
|
|
if (s.SubName == pSubName) {
|
|
return 1;
|
|
}
|
|
if (resolve > ResolveMode::OldStyleElement && boost::starts_with(s.SubName, prefix)) {
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
if (resolve == ResolveMode::OldStyleElement) {
|
|
for (auto& s : *selList) {
|
|
if (s.pResolvedObject != sel.pResolvedObject) {
|
|
continue;
|
|
}
|
|
if (!pSubName[0]) {
|
|
return 1;
|
|
}
|
|
if (!s.elementName.newName.empty()) {
|
|
if (s.elementName.newName == sel.elementName.newName) {
|
|
return 1;
|
|
}
|
|
}
|
|
else if (s.SubName == sel.elementName.oldName) {
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
const char* SelectionSingleton::getSelectedElement(App::DocumentObject* obj, const char* pSubName) const
|
|
{
|
|
if (!obj) {
|
|
return nullptr;
|
|
}
|
|
|
|
for (list<_SelObj>::const_iterator It = _SelList.begin(); It != _SelList.end(); ++It) {
|
|
if (It->pObject == obj) {
|
|
auto len = It->SubName.length();
|
|
if (!len) {
|
|
return "";
|
|
}
|
|
if (pSubName && strncmp(pSubName, It->SubName.c_str(), It->SubName.length()) == 0) {
|
|
if (pSubName[len] == 0 || pSubName[len - 1] == '.') {
|
|
return It->SubName.c_str();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void SelectionSingleton::slotDeletedObject(const App::DocumentObject& Obj)
|
|
{
|
|
if (!Obj.isAttachedToDocument()) {
|
|
return;
|
|
}
|
|
|
|
// For safety reason, don't bother checking
|
|
rmvPreselect();
|
|
|
|
// Remove also from the selection, if selected
|
|
// We don't walk down the hierarchy for each selection, so there may be stray selection
|
|
std::vector<SelectionChanges> changes;
|
|
for (auto it = _SelList.begin(), itNext = it; it != _SelList.end(); it = itNext) {
|
|
++itNext;
|
|
if (it->pResolvedObject == &Obj || it->pObject == &Obj) {
|
|
changes.emplace_back(
|
|
SelectionChanges::RmvSelection,
|
|
it->DocName,
|
|
it->FeatName,
|
|
it->SubName,
|
|
it->TypeName
|
|
);
|
|
_SelList.erase(it);
|
|
}
|
|
}
|
|
if (!changes.empty()) {
|
|
for (auto& Chng : changes) {
|
|
FC_LOG(
|
|
"Rmv Selection " << Chng.pDocName << '#' << Chng.pObjectName << '.' << Chng.pSubName
|
|
);
|
|
notify(std::move(Chng));
|
|
}
|
|
getMainWindow()->updateActions();
|
|
}
|
|
|
|
if (!_PickedList.empty()) {
|
|
bool changed = false;
|
|
for (auto it = _PickedList.begin(), itNext = it; it != _PickedList.end(); it = itNext) {
|
|
++itNext;
|
|
auto& sel = *it;
|
|
if (sel.DocName == Obj.getDocument()->getName()
|
|
&& sel.FeatName == Obj.getNameInDocument()) {
|
|
changed = true;
|
|
_PickedList.erase(it);
|
|
}
|
|
}
|
|
if (changed) {
|
|
notify(SelectionChanges(SelectionChanges::PickedListChanged));
|
|
}
|
|
}
|
|
}
|
|
|
|
void SelectionSingleton::setSelectionStyle(SelectionStyle selStyle)
|
|
{
|
|
selectionStyle = selStyle;
|
|
}
|
|
|
|
SelectionSingleton::SelectionStyle SelectionSingleton::getSelectionStyle()
|
|
{
|
|
return selectionStyle;
|
|
}
|
|
|
|
//**************************************************************************
|
|
// Construction/Destruction
|
|
|
|
/**
|
|
* A constructor.
|
|
* A more elaborate description of the constructor.
|
|
*/
|
|
SelectionSingleton::SelectionSingleton()
|
|
: CurrentPreselection(SelectionChanges::ClrSelection)
|
|
, selectionStyle(SelectionStyle::NormalSelection)
|
|
{
|
|
hx = 0;
|
|
hy = 0;
|
|
hz = 0;
|
|
ActiveGate = nullptr;
|
|
gateResolve = ResolveMode::OldStyleElement;
|
|
// NOLINTBEGIN
|
|
App::GetApplication().signalDeletedObject.connect(
|
|
std::bind(&Gui::SelectionSingleton::slotDeletedObject, this, sp::_1)
|
|
);
|
|
signalSelectionChanged.connect(
|
|
std::bind(&Gui::SelectionSingleton::slotSelectionChanged, this, sp::_1)
|
|
);
|
|
// NOLINTEND
|
|
}
|
|
|
|
/**
|
|
* A destructor.
|
|
* A more elaborate description of the destructor.
|
|
*/
|
|
SelectionSingleton::~SelectionSingleton() = default;
|
|
|
|
SelectionSingleton* SelectionSingleton::_pcSingleton = nullptr;
|
|
|
|
SelectionSingleton& SelectionSingleton::instance()
|
|
{
|
|
if (!_pcSingleton) {
|
|
_pcSingleton = new SelectionSingleton;
|
|
}
|
|
return *_pcSingleton;
|
|
}
|
|
|
|
void SelectionSingleton::destruct()
|
|
{
|
|
if (_pcSingleton) {
|
|
delete _pcSingleton;
|
|
}
|
|
_pcSingleton = nullptr;
|
|
}
|
|
|
|
//**************************************************************************
|
|
// Python stuff
|
|
|
|
// SelectionSingleton Methods // Methods structure
|
|
PyMethodDef SelectionSingleton::Methods[] = {
|
|
{"addSelection",
|
|
(PyCFunction)SelectionSingleton::sAddSelection,
|
|
METH_VARARGS,
|
|
"addSelection(docName, objName, subName, x=0, y=0, z=0, clear=True) -> None\n"
|
|
"addSelection(obj, subName, x=0, y=0, z=0, clear=True) -> None\n"
|
|
"addSelection(obj, subNames, clear=True) -> None\n"
|
|
"\n"
|
|
"Add an object to the selection.\n"
|
|
"\n"
|
|
"docName : str\n Name of the `App.Document`.\n"
|
|
"objName : str\n Name of the `App.DocumentObject` to add.\n"
|
|
"obj : App.DocumentObject\n Object to add.\n"
|
|
"subName : str\n Subelement name.\n"
|
|
"x : float\n Coordinate `x` of the point to pick.\n"
|
|
"y : float\n Coordinate `y` of the point to pick.\n"
|
|
"z : float\n Coordinate `z` of the point to pick.\n"
|
|
"subNames : list of str\n List of subelement names.\n"
|
|
"clear : bool\n Clear preselection."},
|
|
{"updateSelection",
|
|
(PyCFunction)SelectionSingleton::sUpdateSelection,
|
|
METH_VARARGS,
|
|
"updateSelection(show, obj, subName) -> None\n"
|
|
"\n"
|
|
"Update an object in the selection.\n"
|
|
"\n"
|
|
"show : bool\n Show or hide the selection.\n"
|
|
"obj : App.DocumentObject\n Object to update.\n"
|
|
"subName : str\n Name of the subelement to update."},
|
|
{"removeSelection",
|
|
(PyCFunction)SelectionSingleton::sRemoveSelection,
|
|
METH_VARARGS,
|
|
"removeSelection(obj, subName) -> None\n"
|
|
"removeSelection(docName, objName, subName) -> None\n"
|
|
"\n"
|
|
"Remove an object from the selection.\n"
|
|
"\n"
|
|
"docName : str\n Name of the `App.Document`.\n"
|
|
"objName : str\n Name of the `App.DocumentObject` to remove.\n"
|
|
"obj : App.DocumentObject\n Object to remove.\n"
|
|
"subName : str\n Name of the subelement to remove."},
|
|
{"clearSelection",
|
|
(PyCFunction)SelectionSingleton::sClearSelection,
|
|
METH_VARARGS,
|
|
"clearSelection(docName, clearPreSelect=True) -> None\n"
|
|
"clearSelection(clearPreSelect=True) -> None\n"
|
|
"\n"
|
|
"Clear the selection in the given document. If no document is\n"
|
|
"given the complete selection is cleared.\n"
|
|
"\n"
|
|
"docName : str\n Name of the `App.Document`.\n"
|
|
"clearPreSelect : bool\n Clear preselection."},
|
|
{"isSelected",
|
|
(PyCFunction)SelectionSingleton::sIsSelected,
|
|
METH_VARARGS,
|
|
"isSelected(obj, subName, resolve=ResolveMode.OldStyleElement) -> bool\n"
|
|
"\n"
|
|
"Check if a given object is selected.\n"
|
|
"\n"
|
|
"obj : App.DocumentObject\n Object to check.\n"
|
|
"subName : str\n Name of the subelement.\n"
|
|
"resolve : int\n Resolve subelement reference."},
|
|
{"setPreselection",
|
|
reinterpret_cast<PyCFunction>(reinterpret_cast<void (*)()>(SelectionSingleton::sSetPreselection)),
|
|
METH_VARARGS | METH_KEYWORDS,
|
|
"setPreselection(obj, subName, x=0, y=0, z=0, type=1) -> None\n"
|
|
"\n"
|
|
"Set preselected object.\n"
|
|
"\n"
|
|
"obj : App.DocumentObject\n Object to preselect.\n"
|
|
"subName : str\n Subelement name.\n"
|
|
"x : float\n Coordinate `x` of the point to preselect.\n"
|
|
"y : float\n Coordinate `y` of the point to preselect.\n"
|
|
"z : float\n Coordinate `z` of the point to preselect.\n"
|
|
"type : int"},
|
|
{"getPreselection",
|
|
(PyCFunction)SelectionSingleton::sGetPreselection,
|
|
METH_VARARGS,
|
|
"getPreselection() -> Gui.SelectionObject\n"
|
|
"\n"
|
|
"Get preselected object."},
|
|
{"clearPreselection",
|
|
(PyCFunction)SelectionSingleton::sRemPreselection,
|
|
METH_VARARGS,
|
|
"clearPreselection() -> None\n"
|
|
"\n"
|
|
"Clear the preselection."},
|
|
{"countObjectsOfType",
|
|
(PyCFunction)SelectionSingleton::sCountObjectsOfType,
|
|
METH_VARARGS,
|
|
"countObjectsOfType(type, docName, resolve=ResolveMode.OldStyleElement) -> int\n"
|
|
"\n"
|
|
"Get the number of selected objects. If no document name is given the\n"
|
|
"active document is used and '*' means all documents.\n"
|
|
"\n"
|
|
"type : str\n Object type id name.\n"
|
|
"docName : str\n Name of the `App.Document`.\n"
|
|
"resolve : int"},
|
|
{"getSelection",
|
|
(PyCFunction)SelectionSingleton::sGetSelection,
|
|
METH_VARARGS,
|
|
"getSelection(docName, resolve=ResolveMode.OldStyleElement, single=False) -> list\n"
|
|
"\n"
|
|
"Return a list of selected objects. If no document name is given\n"
|
|
"the active document is used and '*' means all documents.\n"
|
|
"\n"
|
|
"docName : str\n Name of the `App.Document`.\n"
|
|
"resolve : int\n Resolve the subname references.\n"
|
|
" 0: do not resolve, 1: resolve, 2: resolve with element map.\n"
|
|
"single : bool\n Only return if there is only one selection."},
|
|
{"getPickedList",
|
|
(PyCFunction)SelectionSingleton::sGetPickedList,
|
|
1,
|
|
"getPickedList(docName) -> list of Gui.SelectionObject\n"
|
|
"\n"
|
|
"Return a list of SelectionObjects generated by the last mouse click.\n"
|
|
"If no document name is given the active document is used and '*'\n"
|
|
"means all documents.\n"
|
|
"\n"
|
|
"docName : str\n Name of the `App.Document`."},
|
|
{"enablePickedList",
|
|
(PyCFunction)SelectionSingleton::sEnablePickedList,
|
|
METH_VARARGS,
|
|
"enablePickedList(enable=True) -> None\n"
|
|
"\n"
|
|
"Enable/disable pick list.\n"
|
|
"\n"
|
|
"enable : bool"},
|
|
{"getCompleteSelection",
|
|
(PyCFunction)SelectionSingleton::sGetCompleteSelection,
|
|
METH_VARARGS,
|
|
"getCompleteSelection(resolve=ResolveMode.OldStyleElement) -> list\n"
|
|
"\n"
|
|
"Return a list of selected objects across all documents.\n"
|
|
"\n"
|
|
"resolve : int"},
|
|
{"getSelectionEx",
|
|
(PyCFunction)SelectionSingleton::sGetSelectionEx,
|
|
METH_VARARGS,
|
|
"getSelectionEx(docName, resolve=ResolveMode.OldStyleElement, single=False) -> list of "
|
|
"Gui.SelectionObject\n"
|
|
"\n"
|
|
"Return a list of SelectionObjects. If no document name is given the\n"
|
|
"active document is used and '*' means all documents.\n"
|
|
"The SelectionObjects contain a variety of information about the selection,\n"
|
|
"e.g. subelement names.\n"
|
|
"\n"
|
|
"docName : str\n Name of the `App.Document`.\n"
|
|
"resolve : int\n Resolve the subname references.\n"
|
|
" 0: do not resolve, 1: resolve, 2: resolve with element map.\n"
|
|
"single : bool\n Only return if there is only one selection."},
|
|
{"getSelectionObject",
|
|
(PyCFunction)SelectionSingleton::sGetSelectionObject,
|
|
METH_VARARGS,
|
|
"getSelectionObject(docName, objName, subName, point) -> Gui.SelectionObject\n"
|
|
"\n"
|
|
"Return a SelectionObject.\n"
|
|
"\n"
|
|
"docName : str\n Name of the `App.Document`.\n"
|
|
"objName : str\n Name of the `App.DocumentObject` to select.\n"
|
|
"subName : str\n Subelement name.\n"
|
|
"point : tuple\n Coordinates of the point to pick."},
|
|
{"setSelectionStyle",
|
|
(PyCFunction)SelectionSingleton::sSetSelectionStyle,
|
|
METH_VARARGS,
|
|
"setSelectionStyle(selectionStyle) -> None\n"
|
|
"\n"
|
|
"Change the selection style. 0 for normal selection, 1 for greedy selection\n"
|
|
"\n"
|
|
"selectionStyle : int"},
|
|
{"addObserver",
|
|
(PyCFunction)SelectionSingleton::sAddSelObserver,
|
|
METH_VARARGS,
|
|
"addObserver(object, resolve=ResolveMode.OldStyleElement) -> None\n"
|
|
"\n"
|
|
"Install an observer.\n"
|
|
"\n"
|
|
"object : object\n Python object instance.\n"
|
|
"resolve : int"},
|
|
{"removeObserver",
|
|
(PyCFunction)SelectionSingleton::sRemSelObserver,
|
|
METH_VARARGS,
|
|
"removeObserver(object) -> None\n"
|
|
"\n"
|
|
"Uninstall an observer.\n"
|
|
"\n"
|
|
"object : object\n Python object instance."},
|
|
{"addSelectionGate",
|
|
(PyCFunction)SelectionSingleton::sAddSelectionGate,
|
|
METH_VARARGS,
|
|
"addSelectionGate(filter, resolve=ResolveMode.OldStyleElement) -> None\n"
|
|
"\n"
|
|
"Activate the selection gate.\n"
|
|
"The selection gate will prohibit all selections that do not match\n"
|
|
"the given selection criteria.\n"
|
|
"\n"
|
|
"filter : str, SelectionFilter, object\n"
|
|
"resolve : int\n"
|
|
"\n"
|
|
"Examples strings are:\n"
|
|
"Gui.Selection.addSelectionGate('SELECT Part::Feature SUBELEMENT Edge')\n"
|
|
"Gui.Selection.addSelectionGate('SELECT Robot::RobotObject')\n"
|
|
"\n"
|
|
"An instance of SelectionFilter can also be set:\n"
|
|
"filter = Gui.Selection.Filter('SELECT Part::Feature SUBELEMENT Edge')\n"
|
|
"Gui.Selection.addSelectionGate(filter)\n"
|
|
"\n"
|
|
"The most flexible approach is to write a selection gate class that\n"
|
|
"implements the method 'allow':\n"
|
|
"class Gate:\n"
|
|
" def allow(self,doc,obj,sub):\n"
|
|
" return (sub[0:4] == 'Face')\n"
|
|
"Gui.Selection.addSelectionGate(Gate())"},
|
|
{"removeSelectionGate",
|
|
(PyCFunction)SelectionSingleton::sRemoveSelectionGate,
|
|
METH_VARARGS,
|
|
"removeSelectionGate() -> None\n"
|
|
"\n"
|
|
"Remove the active selection gate."},
|
|
{"setVisible",
|
|
(PyCFunction)SelectionSingleton::sSetVisible,
|
|
METH_VARARGS,
|
|
"setVisible(visible=None) -> None\n"
|
|
"\n"
|
|
"Set visibility of all selection items.\n"
|
|
"\n"
|
|
"visible : bool, None\n If None, then toggle visibility."},
|
|
{"pushSelStack",
|
|
(PyCFunction)SelectionSingleton::sPushSelStack,
|
|
METH_VARARGS,
|
|
"pushSelStack(clearForward=True, overwrite=False) -> None\n"
|
|
"\n"
|
|
"Push current selection to stack.\n"
|
|
"\n"
|
|
"clearForward : bool\n Clear the forward selection stack.\n"
|
|
"overwrite : bool\n Overwrite the top back selection stack with current selection."},
|
|
{"hasSelection",
|
|
(PyCFunction)SelectionSingleton::sHasSelection,
|
|
METH_VARARGS,
|
|
"hasSelection(docName, resolve=ResolveMode.NoResolve) -> bool\n"
|
|
"\n"
|
|
"Check if there is any selection. If no document name is given,\n"
|
|
"checks selections in all documents.\n"
|
|
"\n"
|
|
"docName : str\n Name of the `App.Document`.\n"
|
|
"resolve : int"},
|
|
{"hasSubSelection",
|
|
(PyCFunction)SelectionSingleton::sHasSubSelection,
|
|
METH_VARARGS,
|
|
"hasSubSelection(docName, subElement=False) -> bool\n"
|
|
"\n"
|
|
"Check if there is any selection with subname. If no document name\n"
|
|
"is given the active document is used and '*' means all documents.\n"
|
|
"\n"
|
|
"docName : str\n Name of the `App.Document`.\n"
|
|
"subElement : bool"},
|
|
{"getSelectionFromStack",
|
|
(PyCFunction)SelectionSingleton::sGetSelectionFromStack,
|
|
METH_VARARGS,
|
|
"getSelectionFromStack(docName, resolve=ResolveMode.OldStyleElement, index=0) -> list of "
|
|
"Gui.SelectionObject\n"
|
|
"\n"
|
|
"Return SelectionObjects from selection stack. If no document name is given\n"
|
|
"the active document is used and '*' means all documents.\n"
|
|
"\n"
|
|
"docName : str\n Name of the `App.Document`.\n"
|
|
"resolve : int\n Resolve the subname references.\n"
|
|
" 0: do not resolve, 1: resolve, 2: resolve with element map.\n"
|
|
"index : int\n Select stack index.\n"
|
|
" 0: last pushed selection, > 0: trace back, < 0: trace forward."},
|
|
{nullptr, nullptr, 0, nullptr} /* Sentinel */
|
|
};
|
|
|
|
PyObject* SelectionSingleton::sAddSelection(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
SelectionLogDisabler disabler(true);
|
|
PyObject* clearPreselect = Py_True;
|
|
char* objname;
|
|
char* docname;
|
|
char* subname = nullptr;
|
|
float x = 0, y = 0, z = 0;
|
|
if (PyArg_ParseTuple(args, "ss|sfffO!", &docname, &objname, &subname, &x, &y, &z, &PyBool_Type, &clearPreselect)) {
|
|
Selection()
|
|
.addSelection(docname, objname, subname, x, y, z, nullptr, Base::asBoolean(clearPreselect));
|
|
Py_Return;
|
|
}
|
|
|
|
PyErr_Clear();
|
|
PyObject* object;
|
|
subname = nullptr;
|
|
x = 0, y = 0, z = 0;
|
|
if (PyArg_ParseTuple(
|
|
args,
|
|
"O!|sfffO!",
|
|
&(App::DocumentObjectPy::Type),
|
|
&object,
|
|
&subname,
|
|
&x,
|
|
&y,
|
|
&z,
|
|
&PyBool_Type,
|
|
&clearPreselect
|
|
)) {
|
|
auto docObjPy = static_cast<App::DocumentObjectPy*>(object);
|
|
App::DocumentObject* docObj = docObjPy->getDocumentObjectPtr();
|
|
if (!docObj || !docObj->isAttachedToDocument()) {
|
|
PyErr_SetString(Base::PyExc_FC_GeneralError, "Cannot check invalid object");
|
|
return nullptr;
|
|
}
|
|
|
|
Selection().addSelection(
|
|
docObj->getDocument()->getName(),
|
|
docObj->getNameInDocument(),
|
|
subname,
|
|
x,
|
|
y,
|
|
z,
|
|
nullptr,
|
|
Base::asBoolean(clearPreselect)
|
|
);
|
|
Py_Return;
|
|
}
|
|
|
|
PyErr_Clear();
|
|
PyObject* sequence;
|
|
if (PyArg_ParseTuple(
|
|
args,
|
|
"O!O|O!",
|
|
&(App::DocumentObjectPy::Type),
|
|
&object,
|
|
&sequence,
|
|
&PyBool_Type,
|
|
&clearPreselect
|
|
)) {
|
|
auto docObjPy = static_cast<App::DocumentObjectPy*>(object);
|
|
App::DocumentObject* docObj = docObjPy->getDocumentObjectPtr();
|
|
if (!docObj || !docObj->isAttachedToDocument()) {
|
|
PyErr_SetString(Base::PyExc_FC_GeneralError, "Cannot check invalid object");
|
|
return nullptr;
|
|
}
|
|
|
|
try {
|
|
if (PyTuple_Check(sequence) || PyList_Check(sequence)) {
|
|
Py::Sequence list(sequence);
|
|
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
|
|
std::string subname = static_cast<std::string>(Py::String(*it));
|
|
Selection().addSelection(
|
|
docObj->getDocument()->getName(),
|
|
docObj->getNameInDocument(),
|
|
subname.c_str(),
|
|
0,
|
|
0,
|
|
0,
|
|
nullptr,
|
|
Base::asBoolean(clearPreselect)
|
|
);
|
|
}
|
|
Py_Return;
|
|
}
|
|
}
|
|
catch (const Py::Exception&) {
|
|
// do nothing here
|
|
}
|
|
}
|
|
|
|
PyErr_SetString(PyExc_ValueError, "type must be 'DocumentObject[,subname[,x,y,z]]' or 'DocumentObject, list or tuple of subnames'");
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sUpdateSelection(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
PyObject* show;
|
|
PyObject* object;
|
|
char* subname = nullptr;
|
|
if (!PyArg_ParseTuple(
|
|
args,
|
|
"O!O!|s",
|
|
&PyBool_Type,
|
|
&show,
|
|
&(App::DocumentObjectPy::Type),
|
|
&object,
|
|
&subname
|
|
)) {
|
|
return nullptr;
|
|
}
|
|
|
|
auto docObjPy = static_cast<App::DocumentObjectPy*>(object);
|
|
App::DocumentObject* docObj = docObjPy->getDocumentObjectPtr();
|
|
if (!docObj || !docObj->isAttachedToDocument()) {
|
|
PyErr_SetString(Base::PyExc_FC_GeneralError, "Cannot check invalid object");
|
|
return nullptr;
|
|
}
|
|
|
|
Selection().updateSelection(
|
|
Base::asBoolean(show),
|
|
docObj->getDocument()->getName(),
|
|
docObj->getNameInDocument(),
|
|
subname
|
|
);
|
|
|
|
Py_Return;
|
|
}
|
|
|
|
|
|
PyObject* SelectionSingleton::sRemoveSelection(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
SelectionLogDisabler disabler(true);
|
|
char *docname, *objname;
|
|
char* subname = nullptr;
|
|
if (PyArg_ParseTuple(args, "ss|s", &docname, &objname, &subname)) {
|
|
Selection().rmvSelection(docname, objname, subname);
|
|
Py_Return;
|
|
}
|
|
|
|
PyErr_Clear();
|
|
PyObject* object;
|
|
subname = nullptr;
|
|
if (!PyArg_ParseTuple(args, "O!|s", &(App::DocumentObjectPy::Type), &object, &subname)) {
|
|
return nullptr;
|
|
}
|
|
|
|
auto docObjPy = static_cast<App::DocumentObjectPy*>(object);
|
|
App::DocumentObject* docObj = docObjPy->getDocumentObjectPtr();
|
|
if (!docObj || !docObj->isAttachedToDocument()) {
|
|
PyErr_SetString(Base::PyExc_FC_GeneralError, "Cannot check invalid object");
|
|
return nullptr;
|
|
}
|
|
|
|
Selection().rmvSelection(docObj->getDocument()->getName(), docObj->getNameInDocument(), subname);
|
|
|
|
Py_Return;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sClearSelection(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
SelectionLogDisabler disabler(true);
|
|
PyObject* clearPreSelect = Py_True;
|
|
char* documentName = nullptr;
|
|
if (!PyArg_ParseTuple(args, "|O!", &PyBool_Type, &clearPreSelect)) {
|
|
PyErr_Clear();
|
|
if (!PyArg_ParseTuple(args, "|sO!", &documentName, &PyBool_Type, &clearPreSelect)) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
Selection().clearSelection(documentName, Base::asBoolean(clearPreSelect));
|
|
|
|
Py_Return;
|
|
}
|
|
|
|
namespace
|
|
{
|
|
ResolveMode toEnum(int value)
|
|
{
|
|
switch (value) {
|
|
case 0:
|
|
return ResolveMode::NoResolve;
|
|
case 1:
|
|
return ResolveMode::OldStyleElement;
|
|
case 2:
|
|
return ResolveMode::NewStyleElement;
|
|
case 3:
|
|
return ResolveMode::FollowLink;
|
|
default:
|
|
throw Base::ValueError("Wrong enum value");
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
PyObject* SelectionSingleton::sIsSelected(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
PyObject* object;
|
|
char* subname = nullptr;
|
|
int resolve = 1;
|
|
if (!PyArg_ParseTuple(args, "O!|si", &(App::DocumentObjectPy::Type), &object, &subname, &resolve)) {
|
|
return nullptr;
|
|
}
|
|
|
|
try {
|
|
auto docObj = static_cast<App::DocumentObjectPy*>(object);
|
|
bool ok = Selection().isSelected(docObj->getDocumentObjectPtr(), subname, toEnum(resolve));
|
|
|
|
return Py_BuildValue("O", (ok ? Py_True : Py_False));
|
|
}
|
|
catch (const Base::Exception& e) {
|
|
e.setPyException();
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sCountObjectsOfType(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
char* objecttype;
|
|
char* document = nullptr;
|
|
int resolve = 1;
|
|
if (!PyArg_ParseTuple(args, "s|si", &objecttype, &document, &resolve)) {
|
|
return nullptr;
|
|
}
|
|
|
|
try {
|
|
unsigned int count = Selection().countObjectsOfType(objecttype, document, toEnum(resolve));
|
|
return PyLong_FromLong(count);
|
|
}
|
|
catch (const Base::Exception& e) {
|
|
e.setPyException();
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sGetSelection(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
char* documentName = nullptr;
|
|
int resolve = 1;
|
|
PyObject* single = Py_False;
|
|
if (!PyArg_ParseTuple(args, "|siO!", &documentName, &resolve, &PyBool_Type, &single)) {
|
|
return nullptr;
|
|
}
|
|
|
|
try {
|
|
std::vector<SelectionSingleton::SelObj> sel;
|
|
sel = Selection().getSelection(documentName, toEnum(resolve), Base::asBoolean(single));
|
|
|
|
std::set<App::DocumentObject*> noduplicates;
|
|
std::vector<App::DocumentObject*> selectedObjects; // keep the order of selection
|
|
Py::List list;
|
|
for (const auto& it : sel) {
|
|
if (noduplicates.insert(it.pObject).second) {
|
|
selectedObjects.push_back(it.pObject);
|
|
}
|
|
}
|
|
for (const auto& selectedObject : selectedObjects) {
|
|
list.append(Py::asObject(selectedObject->getPyObject()));
|
|
}
|
|
return Py::new_reference_to(list);
|
|
}
|
|
catch (const Base::Exception& e) {
|
|
e.setPyException();
|
|
return nullptr;
|
|
}
|
|
catch (Py::Exception&) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sEnablePickedList(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
PyObject* enable = Py_True;
|
|
if (!PyArg_ParseTuple(args, "|O!", &PyBool_Type, &enable)) {
|
|
return nullptr;
|
|
}
|
|
|
|
Selection().enablePickedList(Base::asBoolean(enable));
|
|
|
|
Py_Return;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sSetPreselection(PyObject* /*self*/, PyObject* args, PyObject* kwd)
|
|
{
|
|
PyObject* object;
|
|
const char* subname = nullptr;
|
|
float x = 0, y = 0, z = 0;
|
|
int type = 1;
|
|
static const std::array<const char*, 7> kwlist {"obj", "subname", "x", "y", "z", "tp", nullptr};
|
|
if (Base::Wrapped_ParseTupleAndKeywords(
|
|
args,
|
|
kwd,
|
|
"O!|sfffi",
|
|
kwlist,
|
|
&(App::DocumentObjectPy::Type),
|
|
&object,
|
|
&subname,
|
|
&x,
|
|
&y,
|
|
&z,
|
|
&type
|
|
)) {
|
|
auto docObjPy = static_cast<App::DocumentObjectPy*>(object);
|
|
App::DocumentObject* docObj = docObjPy->getDocumentObjectPtr();
|
|
if (!docObj || !docObj->isAttachedToDocument()) {
|
|
PyErr_SetString(Base::PyExc_FC_GeneralError, "Cannot check invalid object");
|
|
return nullptr;
|
|
}
|
|
|
|
Selection().setPreselect(
|
|
docObj->getDocument()->getName(),
|
|
docObj->getNameInDocument(),
|
|
subname,
|
|
x,
|
|
y,
|
|
z,
|
|
static_cast<SelectionChanges::MsgSource>(type)
|
|
);
|
|
Py_Return;
|
|
}
|
|
|
|
PyErr_SetString(PyExc_ValueError, "type must be 'DocumentObject[,subname[,x,y,z]]'");
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sGetPreselection(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, "")) {
|
|
return nullptr;
|
|
}
|
|
|
|
const SelectionChanges& sel = Selection().getPreselection();
|
|
SelectionObject obj(sel);
|
|
|
|
return obj.getPyObject();
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sRemPreselection(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, "")) {
|
|
return nullptr;
|
|
}
|
|
|
|
Selection().rmvPreselect();
|
|
|
|
Py_Return;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sGetCompleteSelection(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
int resolve = 1;
|
|
if (!PyArg_ParseTuple(args, "|i", &resolve)) {
|
|
return nullptr;
|
|
}
|
|
|
|
try {
|
|
std::vector<SelectionSingleton::SelObj> sel;
|
|
sel = Selection().getCompleteSelection(toEnum(resolve));
|
|
|
|
Py::List list;
|
|
for (const auto& it : sel) {
|
|
SelectionObject obj(SelectionChanges(
|
|
SelectionChanges::AddSelection,
|
|
it.DocName,
|
|
it.FeatName,
|
|
it.SubName,
|
|
it.TypeName,
|
|
it.x,
|
|
it.y,
|
|
it.z
|
|
));
|
|
list.append(Py::asObject(obj.getPyObject()));
|
|
}
|
|
return Py::new_reference_to(list);
|
|
}
|
|
catch (const Base::Exception& e) {
|
|
e.setPyException();
|
|
return nullptr;
|
|
}
|
|
catch (Py::Exception&) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sGetSelectionEx(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
char* documentName = nullptr;
|
|
int resolve = 1;
|
|
PyObject* single = Py_False;
|
|
if (!PyArg_ParseTuple(args, "|siO!", &documentName, &resolve, &PyBool_Type, &single)) {
|
|
return nullptr;
|
|
}
|
|
|
|
try {
|
|
std::vector<SelectionObject> sel;
|
|
sel = Selection().getSelectionEx(
|
|
documentName,
|
|
App::DocumentObject::getClassTypeId(),
|
|
toEnum(resolve),
|
|
Base::asBoolean(single)
|
|
);
|
|
|
|
Py::List list;
|
|
for (auto& it : sel) {
|
|
list.append(Py::asObject(it.getPyObject()));
|
|
}
|
|
return Py::new_reference_to(list);
|
|
}
|
|
catch (const Base::Exception& e) {
|
|
e.setPyException();
|
|
return nullptr;
|
|
}
|
|
catch (Py::Exception&) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sGetPickedList(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
char* documentName = nullptr;
|
|
if (!PyArg_ParseTuple(args, "|s", &documentName)) {
|
|
return nullptr;
|
|
}
|
|
|
|
std::vector<SelectionObject> sel;
|
|
sel = Selection().getPickedListEx(documentName);
|
|
|
|
try {
|
|
Py::List list;
|
|
for (auto& it : sel) {
|
|
list.append(Py::asObject(it.getPyObject()));
|
|
}
|
|
return Py::new_reference_to(list);
|
|
}
|
|
catch (Py::Exception&) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sGetSelectionObject(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
char *docName, *objName, *subName;
|
|
PyObject* tuple = nullptr;
|
|
if (!PyArg_ParseTuple(args, "sss|O!", &docName, &objName, &subName, &PyTuple_Type, &tuple)) {
|
|
return nullptr;
|
|
}
|
|
|
|
try {
|
|
SelectionObject selObj;
|
|
selObj.DocName = docName;
|
|
selObj.FeatName = objName;
|
|
std::string sub = subName;
|
|
if (!sub.empty()) {
|
|
selObj.SubNames.push_back(sub);
|
|
if (tuple) {
|
|
Py::Tuple t(tuple);
|
|
double x = (double)Py::Float(t.getItem(0));
|
|
double y = (double)Py::Float(t.getItem(1));
|
|
double z = (double)Py::Float(t.getItem(2));
|
|
selObj.SelPoses.emplace_back(x, y, z);
|
|
}
|
|
}
|
|
|
|
return selObj.getPyObject();
|
|
}
|
|
catch (const Py::Exception&) {
|
|
return nullptr;
|
|
}
|
|
catch (const Base::Exception& e) {
|
|
e.setPyException();
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sSetSelectionStyle(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
int selStyle = 0;
|
|
if (!PyArg_ParseTuple(args, "i", &selStyle)) {
|
|
return nullptr;
|
|
}
|
|
|
|
PY_TRY
|
|
{
|
|
Selection().setSelectionStyle(
|
|
selStyle == 0 ? SelectionStyle::NormalSelection : SelectionStyle::GreedySelection
|
|
);
|
|
Py_Return;
|
|
}
|
|
PY_CATCH;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sAddSelObserver(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
PyObject* o;
|
|
int resolve = 1;
|
|
if (!PyArg_ParseTuple(args, "O|i", &o, &resolve)) {
|
|
return nullptr;
|
|
}
|
|
|
|
PY_TRY
|
|
{
|
|
SelectionObserverPython::addObserver(Py::Object(o), toEnum(resolve));
|
|
Py_Return;
|
|
}
|
|
PY_CATCH;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sRemSelObserver(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
PyObject* o;
|
|
if (!PyArg_ParseTuple(args, "O", &o)) {
|
|
return nullptr;
|
|
}
|
|
|
|
PY_TRY
|
|
{
|
|
SelectionObserverPython::removeObserver(Py::Object(o));
|
|
Py_Return;
|
|
}
|
|
PY_CATCH;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sAddSelectionGate(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
char* filter;
|
|
int resolve = 1;
|
|
if (PyArg_ParseTuple(args, "s|i", &filter, &resolve)) {
|
|
PY_TRY
|
|
{
|
|
Selection().addSelectionGate(new SelectionFilterGate(filter), toEnum(resolve));
|
|
Py_Return;
|
|
}
|
|
PY_CATCH;
|
|
}
|
|
|
|
PyErr_Clear();
|
|
PyObject* filterPy;
|
|
if (PyArg_ParseTuple(args, "O!|i", SelectionFilterPy::type_object(), &filterPy, resolve)) {
|
|
PY_TRY
|
|
{
|
|
Selection().addSelectionGate(
|
|
new SelectionFilterGatePython(SelectionFilterPy::cast(filterPy)),
|
|
toEnum(resolve)
|
|
);
|
|
Py_Return;
|
|
}
|
|
PY_CATCH;
|
|
}
|
|
|
|
PyErr_Clear();
|
|
PyObject* gate;
|
|
if (PyArg_ParseTuple(args, "O|i", &gate, &resolve)) {
|
|
PY_TRY
|
|
{
|
|
Selection().addSelectionGate(
|
|
new SelectionGatePython(Py::Object(gate, false)),
|
|
toEnum(resolve)
|
|
);
|
|
Py_Return;
|
|
}
|
|
PY_CATCH;
|
|
}
|
|
|
|
PyErr_SetString(PyExc_ValueError, "Argument is neither string nor SelectionFiler nor SelectionGate");
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sRemoveSelectionGate(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
if (!PyArg_ParseTuple(args, "")) {
|
|
return nullptr;
|
|
}
|
|
|
|
PY_TRY
|
|
{
|
|
Selection().rmvSelectionGate();
|
|
Py_Return;
|
|
}
|
|
PY_CATCH;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sSetVisible(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
PyObject* visible = Py_None;
|
|
if (!PyArg_ParseTuple(args, "|O", &visible)) {
|
|
return nullptr;
|
|
}
|
|
|
|
PY_TRY
|
|
{
|
|
VisibleState vis = VisToggle;
|
|
Base::PyTypeCheck(&visible, &PyBool_Type);
|
|
if (visible) {
|
|
vis = PyObject_IsTrue(visible) ? VisShow : VisHide;
|
|
}
|
|
|
|
Selection().setVisible(vis);
|
|
Py_Return;
|
|
}
|
|
PY_CATCH;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sPushSelStack(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
PyObject* clear = Py_True;
|
|
PyObject* overwrite = Py_False;
|
|
if (!PyArg_ParseTuple(args, "|O!O!", &PyBool_Type, &clear, &PyBool_Type, &overwrite)) {
|
|
return nullptr;
|
|
}
|
|
|
|
Selection().selStackPush(Base::asBoolean(clear), Base::asBoolean(overwrite));
|
|
|
|
Py_Return;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sHasSelection(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
const char* doc = nullptr;
|
|
int resolve = 0;
|
|
if (!PyArg_ParseTuple(args, "|si", &doc, &resolve)) {
|
|
return nullptr;
|
|
}
|
|
|
|
PY_TRY
|
|
{
|
|
bool ret;
|
|
if (doc || resolve > 0) {
|
|
ret = Selection().hasSelection(doc, toEnum(resolve));
|
|
}
|
|
else {
|
|
ret = Selection().hasSelection();
|
|
}
|
|
|
|
return Py::new_reference_to(Py::Boolean(ret));
|
|
}
|
|
PY_CATCH;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sHasSubSelection(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
const char* doc = nullptr;
|
|
PyObject* subElement = Py_False;
|
|
if (!PyArg_ParseTuple(args, "|sO!", &doc, &PyBool_Type, &subElement)) {
|
|
return nullptr;
|
|
}
|
|
|
|
PY_TRY
|
|
{
|
|
return Py::new_reference_to(
|
|
Py::Boolean(Selection().hasSubSelection(doc, Base::asBoolean(subElement)))
|
|
);
|
|
}
|
|
PY_CATCH;
|
|
}
|
|
|
|
PyObject* SelectionSingleton::sGetSelectionFromStack(PyObject* /*self*/, PyObject* args)
|
|
{
|
|
char* documentName = nullptr;
|
|
int resolve = 1;
|
|
int index = 0;
|
|
if (!PyArg_ParseTuple(args, "|sii", &documentName, &resolve, &index)) {
|
|
return nullptr;
|
|
}
|
|
|
|
PY_TRY
|
|
{
|
|
Py::List list;
|
|
for (auto& sel : Selection().selStackGet(documentName, toEnum(resolve), index)) {
|
|
list.append(Py::asObject(sel.getPyObject()));
|
|
}
|
|
return Py::new_reference_to(list);
|
|
}
|
|
PY_CATCH;
|
|
}
|
|
|
|
bool SelectionSingleton::isClarifySelectionActive()
|
|
{
|
|
return clarifySelectionActive;
|
|
}
|
|
|
|
void SelectionSingleton::setClarifySelectionActive(bool active)
|
|
{
|
|
clarifySelectionActive = active;
|
|
}
|