2118 lines
72 KiB
C++
2118 lines
72 KiB
C++
// SPDX-License-Identifier: LGPL-2.1-or-later
|
|
/***************************************************************************
|
|
* Copyright (c) 2005 Jürgen Riegel <juergen.riegel@web.de> *
|
|
* *
|
|
* 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 <FCConfig.h>
|
|
|
|
#include <Inventor/SoFullPath.h>
|
|
#include <Inventor/SoPickedPoint.h>
|
|
#include <Inventor/actions/SoCallbackAction.h>
|
|
#include <Inventor/actions/SoGetBoundingBoxAction.h>
|
|
#include <Inventor/actions/SoGetPrimitiveCountAction.h>
|
|
#include <Inventor/actions/SoGLRenderAction.h>
|
|
#include <Inventor/actions/SoHandleEventAction.h>
|
|
#include <Inventor/actions/SoWriteAction.h>
|
|
#include <Inventor/bundles/SoMaterialBundle.h>
|
|
#include <Inventor/details/SoFaceDetail.h>
|
|
#include <Inventor/details/SoLineDetail.h>
|
|
#include <Inventor/elements/SoCacheElement.h>
|
|
#include <Inventor/elements/SoCoordinateElement.h>
|
|
#include <Inventor/elements/SoDrawStyleElement.h>
|
|
#include <Inventor/elements/SoGLCacheContextElement.h>
|
|
#include <Inventor/elements/SoLazyElement.h>
|
|
#include <Inventor/elements/SoLineWidthElement.h>
|
|
#include <Inventor/elements/SoMaterialBindingElement.h>
|
|
#include <Inventor/elements/SoModelMatrixElement.h>
|
|
#include <Inventor/elements/SoOverrideElement.h>
|
|
#include <Inventor/elements/SoShapeStyleElement.h>
|
|
#include <Inventor/elements/SoSwitchElement.h>
|
|
#include <Inventor/elements/SoTextureEnabledElement.h>
|
|
#include <Inventor/events/SoLocation2Event.h>
|
|
#include <Inventor/events/SoMouseButtonEvent.h>
|
|
#include <Inventor/misc/SoChildList.h>
|
|
#include <Inventor/misc/SoState.h>
|
|
#include <Inventor/nodes/SoCoordinate3.h>
|
|
#include <Inventor/nodes/SoCube.h>
|
|
#include <Inventor/nodes/SoIndexedFaceSet.h>
|
|
#include <Inventor/nodes/SoIndexedLineSet.h>
|
|
#include <Inventor/nodes/SoMaterial.h>
|
|
#include <Inventor/nodes/SoMaterialBinding.h>
|
|
#include <Inventor/nodes/SoNormalBinding.h>
|
|
#include <Inventor/nodes/SoPointSet.h>
|
|
#include <Inventor/threads/SbStorage.h>
|
|
|
|
|
|
#ifdef FC_OS_MACOSX
|
|
# include <OpenGL/gl.h>
|
|
#else
|
|
# ifdef FC_OS_WIN32
|
|
# include <windows.h>
|
|
# endif
|
|
# include <GL/gl.h>
|
|
#endif
|
|
|
|
#include <QOpenGLWidget>
|
|
|
|
#include <App/Document.h>
|
|
#include <App/GeoFeature.h>
|
|
#include <App/ElementNamingUtils.h>
|
|
#include <Base/Tools.h>
|
|
#include <Base/UnitsApi.h>
|
|
|
|
#include "SoFCUnifiedSelection.h"
|
|
#include "Application.h"
|
|
#include "Document.h"
|
|
#include "DocumentObserver.h"
|
|
#include "MainWindow.h"
|
|
#include "SoFCInteractiveElement.h"
|
|
#include "SoFCSelectionAction.h"
|
|
#include "ViewParams.h"
|
|
#include "ViewProvider.h"
|
|
#include "ViewProviderDocumentObject.h"
|
|
|
|
|
|
FC_LOG_LEVEL_INIT("SoFCUnifiedSelection", false, true, true)
|
|
|
|
using namespace Gui;
|
|
|
|
namespace Gui
|
|
{
|
|
void printPreselectionInfo(
|
|
const char* documentName,
|
|
const char* objectName,
|
|
const char* subElementName,
|
|
float x,
|
|
float y,
|
|
float z,
|
|
double precision
|
|
);
|
|
}
|
|
|
|
SoFullPath* Gui::SoFCUnifiedSelection::currentHighlightPath = nullptr;
|
|
|
|
// *************************************************************************
|
|
|
|
SO_NODE_SOURCE(SoFCUnifiedSelection)
|
|
|
|
/*!
|
|
Constructor.
|
|
*/
|
|
SoFCUnifiedSelection::SoFCUnifiedSelection()
|
|
{
|
|
SO_NODE_CONSTRUCTOR(SoFCUnifiedSelection);
|
|
|
|
SO_NODE_ADD_FIELD(colorHighlight, (SbColor(1.0f, 0.6f, 0.0f)));
|
|
SO_NODE_ADD_FIELD(colorSelection, (SbColor(0.1f, 0.8f, 0.1f)));
|
|
SO_NODE_ADD_FIELD(preselectionMode, (AUTO));
|
|
SO_NODE_ADD_FIELD(selectionMode, (ON));
|
|
SO_NODE_ADD_FIELD(selectionEnabled, (true));
|
|
SO_NODE_ADD_FIELD(useNewSelection, (true));
|
|
|
|
SO_NODE_DEFINE_ENUM_VALUE(PreselectionModes, AUTO);
|
|
SO_NODE_DEFINE_ENUM_VALUE(PreselectionModes, ON);
|
|
SO_NODE_DEFINE_ENUM_VALUE(PreselectionModes, OFF);
|
|
SO_NODE_SET_SF_ENUM_TYPE(preselectionMode, PreselectionModes);
|
|
|
|
// Documentation of SoFullPath:
|
|
// Since the SoFullPath is derived from SoPath and contains no private data, you can cast SoPath
|
|
// instances to the SoFullPath type. This will allow you to examine hidden children. Actually,
|
|
// you are not supposed to allocate instances of this class at all. It is only available as an
|
|
// "extended interface" into the superclass SoPath.
|
|
detailPath = static_cast<SoFullPath*>(new SoPath(20));
|
|
detailPath->ref();
|
|
|
|
setPreSelection = false;
|
|
preSelection = -1;
|
|
useNewSelection = ViewParams::instance()->getUseNewSelection();
|
|
}
|
|
|
|
/*!
|
|
Destructor.
|
|
*/
|
|
SoFCUnifiedSelection::~SoFCUnifiedSelection()
|
|
{
|
|
// If we're being deleted and we're the current highlight,
|
|
// NULL out that variable
|
|
if (currentHighlightPath) {
|
|
currentHighlightPath->unref();
|
|
currentHighlightPath = nullptr;
|
|
}
|
|
if (detailPath) {
|
|
detailPath->unref();
|
|
detailPath = nullptr;
|
|
}
|
|
}
|
|
|
|
// doc from parent
|
|
void SoFCUnifiedSelection::initClass()
|
|
{
|
|
SO_NODE_INIT_CLASS(SoFCUnifiedSelection, SoSeparator, "Separator");
|
|
}
|
|
|
|
void SoFCUnifiedSelection::finish()
|
|
{
|
|
atexit_cleanup();
|
|
}
|
|
|
|
bool SoFCUnifiedSelection::hasHighlight()
|
|
{
|
|
return currentHighlightPath != nullptr;
|
|
}
|
|
|
|
void SoFCUnifiedSelection::applySettings()
|
|
{
|
|
float transparency;
|
|
ParameterGrp::handle hGrp = Gui::WindowParameter::getDefaultParameter()->GetGroup("View");
|
|
bool enablePreselection = hGrp->GetBool("EnablePreselection", true);
|
|
if (!enablePreselection) {
|
|
this->preselectionMode = SoFCUnifiedSelection::OFF;
|
|
}
|
|
else {
|
|
// Search for a user defined value with the current color as default
|
|
SbColor highlightColor = this->colorHighlight.getValue();
|
|
auto highlight = (unsigned long)(highlightColor.getPackedValue());
|
|
highlight = hGrp->GetUnsigned("HighlightColor", highlight);
|
|
highlightColor.setPackedValue((uint32_t)highlight, transparency);
|
|
this->colorHighlight.setValue(highlightColor);
|
|
}
|
|
|
|
bool enableSelection = hGrp->GetBool("EnableSelection", true);
|
|
if (!enableSelection) {
|
|
this->selectionMode = SoFCUnifiedSelection::OFF;
|
|
}
|
|
else {
|
|
// Do the same with the selection color
|
|
SbColor selectionColor = this->colorSelection.getValue();
|
|
auto selection = (unsigned long)(selectionColor.getPackedValue());
|
|
selection = hGrp->GetUnsigned("SelectionColor", selection);
|
|
selectionColor.setPackedValue((uint32_t)selection, transparency);
|
|
this->colorSelection.setValue(selectionColor);
|
|
}
|
|
}
|
|
|
|
const char* SoFCUnifiedSelection::getFileFormatName() const
|
|
{
|
|
return "Separator";
|
|
}
|
|
|
|
void SoFCUnifiedSelection::write(SoWriteAction* action)
|
|
{
|
|
SoOutput* out = action->getOutput();
|
|
if (out->getStage() == SoOutput::WRITE) {
|
|
// Do not write out the fields of this class
|
|
if (this->writeHeader(out, true, false)) {
|
|
return;
|
|
}
|
|
SoGroup::doAction(static_cast<SoAction*>(action));
|
|
this->writeFooter(out);
|
|
}
|
|
else {
|
|
inherited::write(action);
|
|
}
|
|
}
|
|
|
|
int SoFCUnifiedSelection::getPriority(const SoPickedPoint* p)
|
|
{
|
|
const SoDetail* detail = p->getDetail();
|
|
if (!detail) {
|
|
return 0;
|
|
}
|
|
if (detail->isOfType(SoFaceDetail::getClassTypeId())) {
|
|
return 1;
|
|
}
|
|
if (detail->isOfType(SoLineDetail::getClassTypeId())) {
|
|
return 2;
|
|
}
|
|
if (detail->isOfType(SoPointDetail::getClassTypeId())) {
|
|
return 3;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
std::vector<SoFCUnifiedSelection::PickedInfo> SoFCUnifiedSelection::getPickedList(
|
|
SoHandleEventAction* action,
|
|
bool singlePick
|
|
) const
|
|
{
|
|
ViewProvider* last_vp = nullptr;
|
|
std::vector<PickedInfo> ret;
|
|
const SoPickedPointList& points = action->getPickedPointList();
|
|
for (int i = 0, count = points.getLength(); i < count; ++i) {
|
|
PickedInfo info;
|
|
info.pp = points[i];
|
|
info.vpd = nullptr;
|
|
ViewProvider* vp = nullptr;
|
|
auto path = static_cast<SoFullPath*>(info.pp->getPath());
|
|
if (this->pcDocument && path && path->containsPath(action->getCurPath())) {
|
|
vp = this->pcDocument->getViewProviderByPathFromHead(path);
|
|
if (singlePick && last_vp && last_vp != vp) {
|
|
return ret;
|
|
}
|
|
}
|
|
if (!vp || !vp->isDerivedFrom(ViewProviderDocumentObject::getClassTypeId())) {
|
|
if (!singlePick) {
|
|
continue;
|
|
}
|
|
if (ret.empty()) {
|
|
ret.push_back(info);
|
|
}
|
|
break;
|
|
}
|
|
info.vpd = static_cast<ViewProviderDocumentObject*>(vp);
|
|
if (!(useNewSelection.getValue() || info.vpd->useNewSelectionModel())
|
|
|| !info.vpd->isSelectable()) {
|
|
if (!singlePick) {
|
|
continue;
|
|
}
|
|
if (ret.empty()) {
|
|
info.vpd = nullptr;
|
|
ret.push_back(info);
|
|
}
|
|
break;
|
|
}
|
|
if (!info.vpd->getElementPicked(info.pp, info.element)) {
|
|
continue;
|
|
}
|
|
|
|
if (singlePick) {
|
|
last_vp = vp;
|
|
}
|
|
ret.push_back(info);
|
|
}
|
|
|
|
if (ret.size() <= 1) {
|
|
return ret;
|
|
}
|
|
|
|
// To identify the picking of lines in a concave area we have to
|
|
// get all intersection points. If we have two or more intersection
|
|
// points where the first is of a face and the second of a line with
|
|
// almost similar coordinates we use the second point, instead.
|
|
|
|
int picked_prio = getPriority(ret[0].pp);
|
|
auto last_vpd = ret[0].vpd;
|
|
const SbVec3f& picked_pt = ret.front().pp->getPoint();
|
|
auto itPicked = ret.begin();
|
|
for (auto it = ret.begin() + 1; it != ret.end(); ++it) {
|
|
auto& info = *it;
|
|
if (last_vpd != info.vpd) {
|
|
break;
|
|
}
|
|
|
|
int cur_prio = getPriority(info.pp);
|
|
const SbVec3f& cur_pt = info.pp->getPoint();
|
|
|
|
if ((cur_prio > picked_prio) && picked_pt.equals(cur_pt, 0.2F)) {
|
|
itPicked = it;
|
|
picked_prio = cur_prio;
|
|
}
|
|
}
|
|
|
|
if (singlePick) {
|
|
std::vector<PickedInfo> sret(itPicked, itPicked + 1);
|
|
return sret;
|
|
}
|
|
if (itPicked != ret.begin()) {
|
|
std::swap(*itPicked, *ret.begin());
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void SoFCUnifiedSelection::doAction(SoAction* action)
|
|
{
|
|
if (action->getTypeId() == SoFCEnablePreselectionAction::getClassTypeId()) {
|
|
auto enablePreselectionAction = static_cast<SoFCEnablePreselectionAction*>(action);
|
|
if (enablePreselectionAction->enabled) {
|
|
this->preselectionMode = SoFCUnifiedSelection::AUTO;
|
|
}
|
|
else {
|
|
this->preselectionMode = SoFCUnifiedSelection::OFF;
|
|
}
|
|
}
|
|
|
|
if (action->getTypeId() == SoFCEnableSelectionAction::getClassTypeId()) {
|
|
auto enableSelectionAction = static_cast<SoFCEnableSelectionAction*>(action);
|
|
if (enableSelectionAction->enabled) {
|
|
this->selectionMode = SoFCUnifiedSelection::ON;
|
|
}
|
|
else {
|
|
this->selectionMode = SoFCUnifiedSelection::OFF;
|
|
}
|
|
}
|
|
|
|
if (action->getTypeId() == SoFCSelectionColorAction::getClassTypeId()) {
|
|
auto selectionColorAction = static_cast<SoFCSelectionColorAction*>(action);
|
|
this->colorSelection = selectionColorAction->selectionColor;
|
|
}
|
|
|
|
if (action->getTypeId() == SoFCHighlightColorAction::getClassTypeId()) {
|
|
auto highlightColorAction = static_cast<SoFCHighlightColorAction*>(action);
|
|
this->colorHighlight = highlightColorAction->highlightColor;
|
|
}
|
|
|
|
if (action->getTypeId() == SoFCPreselectionAction::getClassTypeId()) {
|
|
auto preselectAction = static_cast<SoFCPreselectionAction*>(action);
|
|
// Do not clear currently preselected object when setting new preselection
|
|
if (!setPreSelection && preselectAction->SelChange.Type == SelectionChanges::RmvPreselect) {
|
|
if (currentHighlightPath) {
|
|
SoHighlightElementAction highlightAction;
|
|
highlightAction.apply(currentHighlightPath);
|
|
currentHighlightPath->unref();
|
|
currentHighlightPath = nullptr;
|
|
}
|
|
}
|
|
else if (preselectionMode.getValue() != OFF
|
|
&& preselectAction->SelChange.Type == SelectionChanges::SetPreselect) {
|
|
if (currentHighlightPath) {
|
|
SoHighlightElementAction highlightAction;
|
|
highlightAction.apply(currentHighlightPath);
|
|
currentHighlightPath->unref();
|
|
currentHighlightPath = nullptr;
|
|
}
|
|
|
|
App::Document* doc = App::GetApplication().getDocument(preselectAction->SelChange.pDocName);
|
|
App::DocumentObject* obj = doc->getObject(preselectAction->SelChange.pObjectName);
|
|
ViewProvider* vp = Application::Instance->getViewProvider(obj);
|
|
|
|
// use getDetailPath() like selection does, instead of just getDetail()
|
|
SoDetail* detail = nullptr;
|
|
detailPath->truncate(0);
|
|
auto subName = preselectAction->SelChange.pSubName;
|
|
|
|
SoFullPath* pathToHighlight = nullptr;
|
|
if (vp && vp->isDerivedFrom(ViewProviderDocumentObject::getClassTypeId())
|
|
&& (useNewSelection.getValue() || vp->useNewSelectionModel()) && vp->isSelectable()) {
|
|
|
|
// get proper detail path for sub-objects (like Assembly parts)
|
|
if (!subName || !subName[0] || vp->getDetailPath(subName, detailPath, true, detail)) {
|
|
if (detailPath->getLength()) {
|
|
pathToHighlight = detailPath;
|
|
}
|
|
else {
|
|
// fallback to ViewProvider root if no specific path
|
|
pathToHighlight = static_cast<SoFullPath*>(new SoPath(2));
|
|
pathToHighlight->ref();
|
|
pathToHighlight->append(vp->getRoot());
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
detail = vp->getDetail(subName);
|
|
pathToHighlight = static_cast<SoFullPath*>(new SoPath(2));
|
|
pathToHighlight->ref();
|
|
pathToHighlight->append(vp->getRoot());
|
|
}
|
|
|
|
if (pathToHighlight) {
|
|
SoHighlightElementAction highlightAction;
|
|
highlightAction.setHighlighted(true);
|
|
highlightAction.setColor(this->colorHighlight.getValue());
|
|
highlightAction.setElement(detail);
|
|
highlightAction.apply(pathToHighlight);
|
|
|
|
currentHighlightPath = static_cast<SoFullPath*>(pathToHighlight->copy());
|
|
currentHighlightPath->ref();
|
|
|
|
// clean up temporary path if we created one
|
|
if (pathToHighlight != detailPath) {
|
|
pathToHighlight->unref();
|
|
}
|
|
}
|
|
|
|
delete detail;
|
|
}
|
|
|
|
if (useNewSelection.getValue()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (action->getTypeId() == SoFCSelectionAction::getClassTypeId()) {
|
|
auto selectionAction = static_cast<SoFCSelectionAction*>(action);
|
|
if (selectionMode.getValue() == ON
|
|
&& (selectionAction->SelChange.Type == SelectionChanges::AddSelection
|
|
|| selectionAction->SelChange.Type == SelectionChanges::RmvSelection)) {
|
|
// selection changes inside the 3d view are handled in handleEvent()
|
|
App::Document* doc = App::GetApplication().getDocument(selectionAction->SelChange.pDocName);
|
|
App::DocumentObject* obj = doc->getObject(selectionAction->SelChange.pObjectName);
|
|
ViewProvider* vp = Application::Instance->getViewProvider(obj);
|
|
|
|
// check if the subobject and all its parent containers are selectable
|
|
bool isSelectable = false;
|
|
if (vp) {
|
|
if (selectionAction->SelChange.pSubName && selectionAction->SelChange.pSubName[0]) {
|
|
// get the entire object hierarchy from root to leaf
|
|
auto objList = obj->getSubObjectList(selectionAction->SelChange.pSubName);
|
|
|
|
isSelectable = true;
|
|
for (auto* checkObj : objList) {
|
|
if (auto checkVp = Application::Instance->getViewProvider(checkObj)) {
|
|
if (!checkVp->isSelectable()) {
|
|
isSelectable = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
isSelectable = vp->isSelectable();
|
|
}
|
|
}
|
|
|
|
if (vp && (useNewSelection.getValue() || vp->useNewSelectionModel()) && isSelectable) {
|
|
SoDetail* detail = nullptr;
|
|
detailPath->truncate(0);
|
|
auto subName = selectionAction->SelChange.pSubName;
|
|
App::ElementNamePair elementName;
|
|
;
|
|
App::GeoFeature::resolveElement(obj, subName, elementName);
|
|
if (Data::isMappedElement(subName)
|
|
&& !elementName.oldName.empty()) { // If we have a shortened element name
|
|
subName = elementName.oldName.c_str(); // use it.
|
|
}
|
|
if (!selectionAction->SelChange.pSubName || !selectionAction->SelChange.pSubName[0]
|
|
|| vp->getDetailPath(subName, detailPath, true, detail)) {
|
|
SoSelectionElementAction::Type type = SoSelectionElementAction::None;
|
|
if (selectionAction->SelChange.Type == SelectionChanges::AddSelection) {
|
|
if (detail) {
|
|
type = SoSelectionElementAction::Append;
|
|
}
|
|
else {
|
|
type = SoSelectionElementAction::All;
|
|
}
|
|
}
|
|
else {
|
|
if (detail) {
|
|
type = SoSelectionElementAction::Remove;
|
|
}
|
|
else {
|
|
type = SoSelectionElementAction::None;
|
|
}
|
|
}
|
|
|
|
SoSelectionElementAction selectionAction(type);
|
|
selectionAction.setColor(this->colorSelection.getValue());
|
|
selectionAction.setElement(detail);
|
|
if (detailPath->getLength()) {
|
|
selectionAction.apply(detailPath);
|
|
}
|
|
else {
|
|
selectionAction.apply(vp->getRoot());
|
|
}
|
|
}
|
|
detailPath->truncate(0);
|
|
delete detail;
|
|
}
|
|
}
|
|
else if (selectionAction->SelChange.Type == SelectionChanges::ClrSelection) {
|
|
SoSelectionElementAction selectionAction(SoSelectionElementAction::None);
|
|
for (int i = 0; i < this->getNumChildren(); ++i) {
|
|
selectionAction.apply(this->getChild(i));
|
|
}
|
|
}
|
|
else if (selectionMode.getValue() == ON
|
|
&& selectionAction->SelChange.Type == SelectionChanges::SetSelection) {
|
|
std::vector<ViewProvider*> vps;
|
|
if (this->pcDocument) {
|
|
vps = this->pcDocument->getViewProvidersOfType(
|
|
ViewProviderDocumentObject::getClassTypeId()
|
|
);
|
|
}
|
|
for (const auto& vp : vps) {
|
|
auto vpd = static_cast<ViewProviderDocumentObject*>(vp);
|
|
if (useNewSelection.getValue() || vpd->useNewSelectionModel()) {
|
|
SoSelectionElementAction::Type type;
|
|
if (Selection().isSelected(vpd->getObject()) && vpd->isSelectable()) {
|
|
type = SoSelectionElementAction::All;
|
|
}
|
|
else {
|
|
type = SoSelectionElementAction::None;
|
|
}
|
|
|
|
SoSelectionElementAction selectionAction(type);
|
|
selectionAction.setColor(this->colorSelection.getValue());
|
|
selectionAction.apply(vpd->getRoot());
|
|
}
|
|
}
|
|
}
|
|
else if (selectionAction->SelChange.Type == SelectionChanges::SetPreselectSignal) {
|
|
// selection changes inside the 3d view are handled in handleEvent()
|
|
App::Document* doc = App::GetApplication().getDocument(selectionAction->SelChange.pDocName);
|
|
App::DocumentObject* obj = doc->getObject(selectionAction->SelChange.pObjectName);
|
|
ViewProvider* vp = Application::Instance->getViewProvider(obj);
|
|
if (vp && vp->isDerivedFrom(ViewProviderDocumentObject::getClassTypeId())
|
|
&& (useNewSelection.getValue() || vp->useNewSelectionModel()) && vp->isSelectable()) {
|
|
detailPath->truncate(0);
|
|
SoDetail* det = nullptr;
|
|
if (vp->getDetailPath(selectionAction->SelChange.pSubName, detailPath, true, det)) {
|
|
setPreselect(
|
|
detailPath,
|
|
det,
|
|
static_cast<ViewProviderDocumentObject*>(vp),
|
|
selectionAction->SelChange.pSubName,
|
|
selectionAction->SelChange.x,
|
|
selectionAction->SelChange.y,
|
|
selectionAction->SelChange.z
|
|
);
|
|
}
|
|
delete det;
|
|
}
|
|
}
|
|
|
|
if (useNewSelection.getValue()) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
inherited::doAction(action);
|
|
}
|
|
|
|
bool SoFCUnifiedSelection::setPreselect(const PickedInfo& info)
|
|
{
|
|
if (!info.pp) {
|
|
return setPreselect(nullptr, nullptr, nullptr, nullptr, 0.0, 0.0, 0.0);
|
|
}
|
|
|
|
const auto& pt = info.pp->getPoint();
|
|
return setPreselect(
|
|
static_cast<SoFullPath*>(info.pp->getPath()),
|
|
info.pp->getDetail(),
|
|
info.vpd,
|
|
info.element.c_str(),
|
|
pt[0],
|
|
pt[1],
|
|
pt[2]
|
|
);
|
|
}
|
|
|
|
bool SoFCUnifiedSelection::setPreselect(
|
|
SoFullPath* path,
|
|
const SoDetail* det,
|
|
ViewProviderDocumentObject* vpd,
|
|
const char* element,
|
|
float x,
|
|
float y,
|
|
float z
|
|
)
|
|
{
|
|
Base::FlagToggler<SbBool> flag(setPreSelection);
|
|
|
|
bool highlighted = false;
|
|
if (path && path->getLength() && vpd && vpd->getObject()
|
|
&& vpd->getObject()->isAttachedToDocument()) {
|
|
const char* docname = vpd->getObject()->getDocument()->getName();
|
|
const char* objname = vpd->getObject()->getNameInDocument();
|
|
|
|
this->preSelection = 1;
|
|
|
|
printPreselectionInfo(docname, objname, element, x, y, z, 1e-7);
|
|
|
|
|
|
int ret = Gui::Selection().setPreselect(docname, objname, element, x, y, z);
|
|
if (ret < 0 && currentHighlightPath) {
|
|
return true;
|
|
}
|
|
|
|
if (ret) {
|
|
if (currentHighlightPath) {
|
|
SoHighlightElementAction action;
|
|
action.setHighlighted(false);
|
|
action.apply(currentHighlightPath);
|
|
currentHighlightPath->unref();
|
|
currentHighlightPath = nullptr;
|
|
}
|
|
currentHighlightPath = static_cast<SoFullPath*>(path->copy());
|
|
currentHighlightPath->ref();
|
|
highlighted = true;
|
|
}
|
|
}
|
|
|
|
if (currentHighlightPath) {
|
|
SoHighlightElementAction action;
|
|
action.setHighlighted(highlighted);
|
|
action.setColor(this->colorHighlight.getValue());
|
|
action.setElement(det);
|
|
action.apply(currentHighlightPath);
|
|
if (!highlighted) {
|
|
currentHighlightPath->unref();
|
|
currentHighlightPath = nullptr;
|
|
Selection().rmvPreselect();
|
|
}
|
|
this->touch();
|
|
}
|
|
return highlighted;
|
|
}
|
|
|
|
bool SoFCUnifiedSelection::setSelection(const std::vector<PickedInfo>& infos, bool ctrlDown)
|
|
{
|
|
if (infos.empty() || !infos[0].vpd) {
|
|
return false;
|
|
}
|
|
|
|
std::vector<SelectionSingleton::SelObj> sels;
|
|
if (infos.size() > 1) {
|
|
for (auto& info : infos) {
|
|
if (!info.vpd) {
|
|
continue;
|
|
}
|
|
|
|
SelectionSingleton::SelObj sel;
|
|
sel.pResolvedObject = nullptr;
|
|
sel.pObject = info.vpd->getObject();
|
|
sel.pDoc = sel.pObject->getDocument();
|
|
sel.DocName = sel.pDoc->getName();
|
|
sel.FeatName = sel.pObject->getNameInDocument();
|
|
sel.TypeName = sel.pObject->getTypeId().getName();
|
|
sel.SubName = info.element.c_str();
|
|
const auto& pt = info.pp->getPoint();
|
|
sel.x = pt[0];
|
|
sel.y = pt[1];
|
|
sel.z = pt[2];
|
|
sels.push_back(sel);
|
|
}
|
|
}
|
|
|
|
const auto& info = infos[0];
|
|
auto vpd = info.vpd;
|
|
if (!vpd) {
|
|
return false;
|
|
}
|
|
if (!vpd->getObject()->isAttachedToDocument()) {
|
|
return false;
|
|
}
|
|
const char* objname = vpd->getObject()->getNameInDocument();
|
|
const char* docname = vpd->getObject()->getDocument()->getName();
|
|
|
|
auto getFullSubElementName = [vpd](std::string& subName) {
|
|
App::ElementNamePair elementName;
|
|
App::GeoFeature::resolveElement(vpd->getObject(), subName.c_str(), elementName);
|
|
if (!elementName.newName.empty()) { // If we have a mapped name use it
|
|
auto elementNameSuffix = Data::findElementName(subName.c_str()); // Only suffix
|
|
subName.erase(subName.find(elementNameSuffix)); // Everything except original suffix
|
|
subName = subName.append(elementName.newName); // Add the mapped name suffix,
|
|
}
|
|
};
|
|
|
|
bool hasNext = false;
|
|
const SoPickedPoint* pp = info.pp;
|
|
const SoDetail* det = pp->getDetail();
|
|
SoDetail* detNext = nullptr;
|
|
auto pPath = static_cast<SoFullPath*>(pp->getPath());
|
|
const auto& pt = pp->getPoint();
|
|
SoSelectionElementAction::Type type = SoSelectionElementAction::None;
|
|
auto preselectionMode = static_cast<SelectionModes>(this->preselectionMode.getValue());
|
|
static char buf[513];
|
|
auto subName = info.element;
|
|
std::string objectName = objname;
|
|
|
|
if (ctrlDown) {
|
|
if (Gui::Selection().isSelected(docname, objname, info.element.c_str(), ResolveMode::NoResolve)) {
|
|
Gui::Selection().rmvSelection(docname, objname, info.element.c_str(), &sels);
|
|
return true;
|
|
}
|
|
else {
|
|
// Changing the selection may result in destroying this view provider.
|
|
// So, make sure that the object still exists afterwards (#17965)
|
|
ViewProviderWeakPtrT guard(vpd);
|
|
getFullSubElementName(subName);
|
|
bool ok = Gui::Selection()
|
|
.addSelection(docname, objname, subName.c_str(), pt[0], pt[1], pt[2], &sels);
|
|
if (guard.expired()) {
|
|
return false;
|
|
}
|
|
|
|
if (ok && preselectionMode == OFF) {
|
|
snprintf(
|
|
buf,
|
|
512,
|
|
"Selected: %s.%s.%s (%g, %g, %g)",
|
|
docname,
|
|
objname,
|
|
info.element.c_str(),
|
|
fabs(pt[0]) > 1e-7 ? pt[0] : 0.0,
|
|
fabs(pt[1]) > 1e-7 ? pt[1] : 0.0,
|
|
fabs(pt[2]) > 1e-7 ? pt[2] : 0.0
|
|
);
|
|
|
|
getMainWindow()->showMessage(QString::fromLatin1(buf));
|
|
}
|
|
detailPath->truncate(0);
|
|
if (vpd->getDetailPath(info.element.c_str(), detailPath, true, detNext)
|
|
&& detailPath->getLength()) {
|
|
pPath = detailPath;
|
|
det = detNext;
|
|
FC_TRACE("select next " << objectName << ", " << subName);
|
|
if (ok) {
|
|
type = hasNext ? SoSelectionElementAction::All : SoSelectionElementAction::Append;
|
|
}
|
|
else {
|
|
// don't apply any visual action when selection fails -
|
|
// in a case when we press ctrl and select a geometry that should be
|
|
// filtered out, we don't want to apply any visual action
|
|
pPath = nullptr;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// Hierarchy ascending
|
|
//
|
|
// If the clicked subelement is already selected, check if there is an
|
|
// upper hierarchy, and select that hierarchy instead.
|
|
//
|
|
// For example, let's suppose PickedInfo above reports
|
|
// 'link.link2.box.Face1', and below Selection().getSelectedElement returns
|
|
// 'link.link2.box.', meaning that 'box' is the current selected hierarchy,
|
|
// and the user is clicking the box again. So we shall go up one level,
|
|
// and select 'link.link2.'
|
|
//
|
|
|
|
|
|
// We need to convert the short name in the selection to a full element path to look it up
|
|
// Ex: Body.Pad.Face9 to Body.Pad.;g3;SKT;:H12dc,E;FAC;:H12dc:4,F;:G0;XTR;:H12dc:8,F.Face9
|
|
getFullSubElementName(subName);
|
|
const char* subSelected
|
|
= Gui::Selection().getSelectedElement(vpd->getObject(), subName.c_str());
|
|
|
|
FC_TRACE(
|
|
"select " << (subSelected ? subSelected : "'null'") << ", " << objectName << ", " << subName
|
|
);
|
|
std::string newElement;
|
|
if (subSelected) {
|
|
newElement = Data::newElementName(subSelected);
|
|
subSelected = newElement.c_str();
|
|
std::string nextsub;
|
|
const char* next = strrchr(subSelected, '.');
|
|
if (next && next != subSelected) {
|
|
if (next[1] == 0) {
|
|
// The convention of dot separated SubName demands a mandatory
|
|
// ending dot for every object name reference inside SubName.
|
|
// The non-object sub-element, however, must not end with a dot.
|
|
// So, next[1]==0 here means current selection is a whole object
|
|
// selection (because no sub-element), so we shall search
|
|
// upwards for the second last dot, which is the end of the
|
|
// parent name of the current selected object
|
|
for (--next; next != subSelected; --next) {
|
|
if (*next == '.') {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (*next == '.') {
|
|
nextsub = std::string(subSelected, next - subSelected + 1);
|
|
}
|
|
}
|
|
if (nextsub.length() || *subSelected != 0) {
|
|
hasNext = true;
|
|
subName = nextsub;
|
|
detailPath->truncate(0);
|
|
if (vpd->getDetailPath(subName.c_str(), detailPath, true, detNext)
|
|
&& detailPath->getLength()) {
|
|
pPath = detailPath;
|
|
det = detNext;
|
|
FC_TRACE("select next " << objectName << ", " << subName);
|
|
}
|
|
}
|
|
}
|
|
|
|
FC_TRACE("clearing selection");
|
|
Gui::Selection().clearSelection();
|
|
FC_TRACE("add selection");
|
|
bool ok = Gui::Selection().addSelection(
|
|
docname,
|
|
objectName.c_str(),
|
|
subName.c_str(),
|
|
pt[0],
|
|
pt[1],
|
|
pt[2],
|
|
&sels
|
|
);
|
|
if (ok) {
|
|
type = hasNext ? SoSelectionElementAction::All : SoSelectionElementAction::Append;
|
|
}
|
|
|
|
if (preselectionMode == OFF) {
|
|
snprintf(
|
|
buf,
|
|
512,
|
|
"Selected: %s.%s.%s (%g, %g, %g)",
|
|
docname,
|
|
objectName.c_str(),
|
|
subName.c_str(),
|
|
fabs(pt[0]) > 1e-7 ? pt[0] : 0.0,
|
|
fabs(pt[1]) > 1e-7 ? pt[1] : 0.0,
|
|
fabs(pt[2]) > 1e-7 ? pt[2] : 0.0
|
|
);
|
|
|
|
getMainWindow()->showMessage(QString::fromLatin1(buf));
|
|
}
|
|
}
|
|
|
|
if (pPath) {
|
|
FC_TRACE("applying action");
|
|
SoSelectionElementAction action(type);
|
|
action.setColor(this->colorSelection.getValue());
|
|
action.setElement(det);
|
|
action.apply(pPath);
|
|
FC_TRACE("applied action");
|
|
this->touch();
|
|
}
|
|
|
|
if (detNext) {
|
|
delete detNext;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// doc from parent
|
|
void SoFCUnifiedSelection::handleEvent(SoHandleEventAction* action)
|
|
{
|
|
// If off then don't handle this event
|
|
if (!selectionEnabled.getValue()) {
|
|
inherited::handleEvent(action);
|
|
return;
|
|
}
|
|
|
|
auto preselectionMode = static_cast<SelectionModes>(this->preselectionMode.getValue());
|
|
const SoEvent* event = action->getEvent();
|
|
|
|
//
|
|
// If this is a mouseMotion event, then check for preselected entities.
|
|
//
|
|
bool isMouseMotionEvent = event->isOfType(SoLocation2Event::getClassTypeId());
|
|
if (isMouseMotionEvent) {
|
|
// NOTE: If preselection is off then we do not check for a picked point because otherwise
|
|
// this search may slow down extremely the system on really big data sets. In this case we
|
|
// just check for a picked point if the data set has been selected.
|
|
if (preselectionMode == AUTO || preselectionMode == ON) {
|
|
// check to see if the mouse is over our geometry...
|
|
auto infos = this->getPickedList(action, true);
|
|
if (!infos.empty()) {
|
|
setPreselect(infos[0]);
|
|
}
|
|
else {
|
|
setPreselect(PickedInfo());
|
|
if (this->preSelection > 0) {
|
|
this->preSelection = 0;
|
|
// touch() makes sure to call GLRenderBelowPath so that the cursor can be updated
|
|
// because only from there the SoGLWidgetElement delivers the OpenGL window
|
|
this->touch();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// mouse press events for (de)selection
|
|
else if (event->isOfType(SoMouseButtonEvent::getClassTypeId())
|
|
&& selectionMode.getValue() == SoFCUnifiedSelection::ON) {
|
|
const auto e = static_cast<const SoMouseButtonEvent*>(event);
|
|
if (SoMouseButtonEvent::isButtonReleaseEvent(e, SoMouseButtonEvent::BUTTON1)) {
|
|
// check to see if the mouse is over a geometry...
|
|
auto infos = this->getPickedList(action, !Selection().needPickedList());
|
|
bool greedySel = Gui::Selection().getSelectionStyle()
|
|
== Gui::SelectionSingleton::SelectionStyle::GreedySelection;
|
|
greedySel = greedySel || event->wasCtrlDown();
|
|
if (setSelection(infos, greedySel) || greedySel) {
|
|
action->setHandled();
|
|
}
|
|
} // mouse release
|
|
}
|
|
|
|
inherited::handleEvent(action);
|
|
}
|
|
|
|
void SoFCUnifiedSelection::GLRenderBelowPath(SoGLRenderAction* action)
|
|
{
|
|
inherited::GLRenderBelowPath(action);
|
|
|
|
// nothing picked, so restore the arrow cursor if needed
|
|
if (this->preSelection == 0) {
|
|
// this is called when a selection gate forbade to select an object
|
|
// and the user moved the mouse to an empty area
|
|
this->preSelection = -1;
|
|
QOpenGLWidget* window;
|
|
SoState* state = action->getState();
|
|
SoGLWidgetElement::get(state, window);
|
|
QWidget* parent = window ? window->parentWidget() : nullptr;
|
|
if (parent) {
|
|
QCursor c = parent->cursor();
|
|
if (c.shape() == Qt::ForbiddenCursor) {
|
|
c.setShape(Qt::ArrowCursor);
|
|
parent->setCursor(c);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
SO_ACTION_SOURCE(SoHighlightElementAction)
|
|
|
|
void SoHighlightElementAction::initClass()
|
|
{
|
|
SO_ACTION_INIT_CLASS(SoHighlightElementAction, SoAction);
|
|
|
|
SO_ENABLE(SoHighlightElementAction, SoSwitchElement);
|
|
SO_ENABLE(SoHighlightElementAction, SoModelMatrixElement);
|
|
|
|
SO_ACTION_ADD_METHOD(SoNode, nullAction);
|
|
|
|
SO_ENABLE(SoHighlightElementAction, SoCoordinateElement);
|
|
|
|
SO_ACTION_ADD_METHOD(SoGroup, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoIndexedLineSet, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoIndexedFaceSet, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoPointSet, callDoAction);
|
|
}
|
|
|
|
SoHighlightElementAction::SoHighlightElementAction()
|
|
{
|
|
SO_ACTION_CONSTRUCTOR(SoHighlightElementAction);
|
|
}
|
|
|
|
SoHighlightElementAction::~SoHighlightElementAction() = default;
|
|
|
|
void SoHighlightElementAction::beginTraversal(SoNode* node)
|
|
{
|
|
traverse(node);
|
|
}
|
|
|
|
void SoHighlightElementAction::callDoAction(SoAction* action, SoNode* node)
|
|
{
|
|
node->doAction(action);
|
|
}
|
|
|
|
void SoHighlightElementAction::setHighlighted(SbBool ok)
|
|
{
|
|
this->_highlight = ok;
|
|
}
|
|
|
|
SbBool SoHighlightElementAction::isHighlighted() const
|
|
{
|
|
return this->_highlight;
|
|
}
|
|
|
|
void SoHighlightElementAction::setColor(const SbColor& c)
|
|
{
|
|
this->_color = c;
|
|
}
|
|
|
|
const SbColor& SoHighlightElementAction::getColor() const
|
|
{
|
|
return this->_color;
|
|
}
|
|
|
|
void SoHighlightElementAction::setElement(const SoDetail* det)
|
|
{
|
|
this->_det = det;
|
|
}
|
|
|
|
const SoDetail* SoHighlightElementAction::getElement() const
|
|
{
|
|
return this->_det;
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
SO_ACTION_SOURCE(SoSelectionElementAction)
|
|
|
|
void SoSelectionElementAction::initClass()
|
|
{
|
|
SO_ACTION_INIT_CLASS(SoSelectionElementAction, SoAction);
|
|
|
|
SO_ENABLE(SoSelectionElementAction, SoSwitchElement);
|
|
SO_ENABLE(SoSelectionElementAction, SoModelMatrixElement);
|
|
|
|
SO_ACTION_ADD_METHOD(SoNode, nullAction);
|
|
|
|
SO_ENABLE(SoSelectionElementAction, SoCoordinateElement);
|
|
|
|
SO_ACTION_ADD_METHOD(SoCoordinate3, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoGroup, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoIndexedLineSet, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoIndexedFaceSet, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoPointSet, callDoAction);
|
|
}
|
|
|
|
SoSelectionElementAction::SoSelectionElementAction(Type t, bool secondary)
|
|
: _type(t)
|
|
, _secondary(secondary)
|
|
{
|
|
SO_ACTION_CONSTRUCTOR(SoSelectionElementAction);
|
|
}
|
|
|
|
SoSelectionElementAction::~SoSelectionElementAction() = default;
|
|
|
|
void SoSelectionElementAction::beginTraversal(SoNode* node)
|
|
{
|
|
traverse(node);
|
|
}
|
|
|
|
void SoSelectionElementAction::callDoAction(SoAction* action, SoNode* node)
|
|
{
|
|
node->doAction(action);
|
|
}
|
|
|
|
SoSelectionElementAction::Type SoSelectionElementAction::getType() const
|
|
{
|
|
return this->_type;
|
|
}
|
|
|
|
void SoSelectionElementAction::setColor(const SbColor& c)
|
|
{
|
|
this->_color = c;
|
|
}
|
|
|
|
const SbColor& SoSelectionElementAction::getColor() const
|
|
{
|
|
return this->_color;
|
|
}
|
|
|
|
void SoSelectionElementAction::setElement(const SoDetail* det)
|
|
{
|
|
this->_det = det;
|
|
}
|
|
|
|
const SoDetail* SoSelectionElementAction::getElement() const
|
|
{
|
|
return this->_det;
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
SO_ACTION_SOURCE(SoVRMLAction)
|
|
|
|
void SoVRMLAction::initClass()
|
|
{
|
|
SO_ACTION_INIT_CLASS(SoVRMLAction, SoAction);
|
|
|
|
SO_ENABLE(SoVRMLAction, SoSwitchElement);
|
|
|
|
SO_ACTION_ADD_METHOD(SoNode, nullAction);
|
|
|
|
SO_ENABLE(SoVRMLAction, SoCoordinateElement);
|
|
SO_ENABLE(SoVRMLAction, SoMaterialBindingElement);
|
|
SO_ENABLE(SoVRMLAction, SoLazyElement);
|
|
SO_ENABLE(SoVRMLAction, SoShapeStyleElement);
|
|
|
|
SO_ACTION_ADD_METHOD(SoCoordinate3, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoMaterialBinding, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoMaterial, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoNormalBinding, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoGroup, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoIndexedLineSet, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoIndexedFaceSet, callDoAction);
|
|
SO_ACTION_ADD_METHOD(SoPointSet, callDoAction);
|
|
}
|
|
|
|
SoVRMLAction::SoVRMLAction()
|
|
{
|
|
SO_ACTION_CONSTRUCTOR(SoVRMLAction);
|
|
}
|
|
|
|
SoVRMLAction::~SoVRMLAction() = default;
|
|
|
|
void SoVRMLAction::setOverrideMode(SbBool on)
|
|
{
|
|
overrideMode = on;
|
|
}
|
|
|
|
SbBool SoVRMLAction::isOverrideMode() const
|
|
{
|
|
return overrideMode;
|
|
}
|
|
|
|
void SoVRMLAction::callDoAction(SoAction* action, SoNode* node)
|
|
{
|
|
if (node->getTypeId().isDerivedFrom(SoNormalBinding::getClassTypeId())
|
|
&& action->isOfType(SoVRMLAction::getClassTypeId())) {
|
|
auto vrmlAction = static_cast<SoVRMLAction*>(action);
|
|
if (vrmlAction->overrideMode) {
|
|
auto bind = static_cast<SoNormalBinding*>(node);
|
|
vrmlAction->bindList.push_back(bind->value.getValue());
|
|
// this normal binding causes some problems for the part view provider
|
|
// See also #0002222: Number of normals in exported VRML is wrong
|
|
if (bind->value.getValue() == static_cast<int>(SoNormalBinding::PER_VERTEX_INDEXED)) {
|
|
bind->value = SoNormalBinding::OVERALL;
|
|
}
|
|
}
|
|
else if (!vrmlAction->bindList.empty()) {
|
|
static_cast<SoNormalBinding*>(node)->value = static_cast<SoNormalBinding::Binding>(
|
|
vrmlAction->bindList.front()
|
|
);
|
|
vrmlAction->bindList.pop_front();
|
|
}
|
|
}
|
|
|
|
node->doAction(action);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------
|
|
|
|
bool SoFCSelectionRoot::StackComp::operator()(const Stack& a, const Stack& b) const
|
|
{
|
|
if (a.size() - a.offset < b.size() - b.offset) {
|
|
return true;
|
|
}
|
|
if (a.size() - a.offset > b.size() - b.offset) {
|
|
return false;
|
|
}
|
|
auto it1 = a.rbegin(), end1 = a.rend() - a.offset;
|
|
auto it2 = b.rbegin();
|
|
for (; it1 != end1; ++it1, ++it2) {
|
|
if (*it1 < *it2) {
|
|
return true;
|
|
}
|
|
if (*it1 > *it2) {
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
// ---------------------------------------------------------------------------------
|
|
SoSeparator::CacheEnabled SoFCSeparator::CacheMode = SoSeparator::AUTO;
|
|
SO_NODE_SOURCE(SoFCSeparator)
|
|
|
|
SoFCSeparator::SoFCSeparator(bool trackCacheMode)
|
|
: trackCacheMode(trackCacheMode)
|
|
{
|
|
SO_NODE_CONSTRUCTOR(SoFCSeparator);
|
|
if (!trackCacheMode) {
|
|
renderCaching = SoSeparator::OFF;
|
|
boundingBoxCaching = SoSeparator::OFF;
|
|
}
|
|
}
|
|
|
|
void SoFCSeparator::GLRenderBelowPath(SoGLRenderAction* action)
|
|
{
|
|
if (trackCacheMode && renderCaching.getValue() != CacheMode) {
|
|
renderCaching = CacheMode;
|
|
boundingBoxCaching = CacheMode;
|
|
}
|
|
inherited::GLRenderBelowPath(action);
|
|
}
|
|
|
|
void SoFCSeparator::initClass()
|
|
{
|
|
SO_NODE_INIT_CLASS(SoFCSeparator, SoSeparator, "FCSeparator");
|
|
}
|
|
|
|
void SoFCSeparator::finish()
|
|
{
|
|
atexit_cleanup();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------
|
|
// Thread local data for bounding box rendering
|
|
//
|
|
// The code is inspred by Coin SoLevelOfDetails.cpp.
|
|
using SoFCBBoxRenderInfo = struct
|
|
{
|
|
SoGetBoundingBoxAction* bboxaction;
|
|
SoCube* cube;
|
|
SoColorPacker* packer;
|
|
};
|
|
|
|
static void so_bbox_construct_data(void* closure)
|
|
{
|
|
auto data = static_cast<SoFCBBoxRenderInfo*>(closure);
|
|
data->bboxaction = nullptr;
|
|
data->cube = nullptr;
|
|
data->packer = nullptr;
|
|
}
|
|
|
|
static void so_bbox_destruct_data(void* closure)
|
|
{
|
|
auto data = static_cast<SoFCBBoxRenderInfo*>(closure);
|
|
delete data->bboxaction;
|
|
if (data->cube) {
|
|
data->cube->unref();
|
|
}
|
|
delete data->packer;
|
|
}
|
|
|
|
static SbStorage* so_bbox_storage = nullptr;
|
|
|
|
// called from atexit
|
|
static void so_bbox_cleanup()
|
|
{
|
|
delete so_bbox_storage;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------
|
|
|
|
SoFCSelectionRoot::Stack SoFCSelectionRoot::SelStack;
|
|
std::unordered_map<SoAction*, SoFCSelectionRoot::Stack> SoFCSelectionRoot::ActionStacks;
|
|
SoFCSelectionRoot::ColorStack SoFCSelectionRoot::SelColorStack;
|
|
SoFCSelectionRoot::ColorStack SoFCSelectionRoot::HlColorStack;
|
|
SoFCSelectionRoot* SoFCSelectionRoot::ShapeColorNode;
|
|
|
|
SO_NODE_SOURCE(SoFCSelectionRoot)
|
|
|
|
SoFCSelectionRoot::SoFCSelectionRoot(bool trackCacheMode)
|
|
: SoFCSeparator(trackCacheMode)
|
|
{
|
|
SO_NODE_CONSTRUCTOR(SoFCSelectionRoot);
|
|
SO_NODE_ADD_FIELD(selectionStyle, (Full));
|
|
SO_NODE_DEFINE_ENUM_VALUE(SelectStyles, Full);
|
|
SO_NODE_DEFINE_ENUM_VALUE(SelectStyles, Box);
|
|
SO_NODE_DEFINE_ENUM_VALUE(SelectStyles, PassThrough);
|
|
SO_NODE_SET_SF_ENUM_TYPE(selectionStyle, SelectStyles);
|
|
}
|
|
|
|
SoFCSelectionRoot::~SoFCSelectionRoot() = default;
|
|
|
|
void SoFCSelectionRoot::initClass()
|
|
{
|
|
SO_NODE_INIT_CLASS(SoFCSelectionRoot, SoFCSeparator, "FCSelectionRoot");
|
|
|
|
so_bbox_storage
|
|
= new SbStorage(sizeof(SoFCBBoxRenderInfo), so_bbox_construct_data, so_bbox_destruct_data);
|
|
|
|
// cc_coin_atexit((coin_atexit_f*) so_bbox_cleanup);
|
|
}
|
|
|
|
void SoFCSelectionRoot::finish()
|
|
{
|
|
so_bbox_cleanup();
|
|
atexit_cleanup();
|
|
}
|
|
|
|
SoNode* SoFCSelectionRoot::getCurrentRoot(bool front, SoNode* def)
|
|
{
|
|
if (!SelStack.empty()) {
|
|
return front ? SelStack.front() : SelStack.back();
|
|
}
|
|
return def;
|
|
}
|
|
|
|
SoFCSelectionContextBasePtr SoFCSelectionRoot::getNodeContext(
|
|
Stack& stack,
|
|
SoNode* node,
|
|
SoFCSelectionContextBasePtr def
|
|
)
|
|
{
|
|
if (stack.empty()) {
|
|
return def;
|
|
}
|
|
|
|
auto front = dynamic_cast<SoFCSelectionRoot*>(stack.front());
|
|
if (front == nullptr) {
|
|
return SoFCSelectionContextBasePtr();
|
|
}
|
|
|
|
stack.front() = node;
|
|
|
|
auto it = front->contextMap.find(stack);
|
|
stack.front() = front;
|
|
if (it != front->contextMap.end()) {
|
|
return it->second;
|
|
}
|
|
return {};
|
|
}
|
|
|
|
SoFCSelectionContextBasePtr SoFCSelectionRoot::getNodeContext2(
|
|
Stack& stack,
|
|
SoNode* node,
|
|
SoFCSelectionContextBase::MergeFunc* merge
|
|
)
|
|
{
|
|
SoFCSelectionContextBasePtr ret;
|
|
if (stack.empty()) {
|
|
return ret;
|
|
}
|
|
|
|
auto* back = dynamic_cast<SoFCSelectionRoot*>(stack.back());
|
|
if (back == nullptr || back->contextMap2.empty()) {
|
|
return ret;
|
|
}
|
|
|
|
int status = 0;
|
|
auto& map = back->contextMap2;
|
|
stack.back() = node;
|
|
for (stack.offset = 0; stack.offset < stack.size(); ++stack.offset) {
|
|
auto it = map.find(stack);
|
|
SoFCSelectionContextBasePtr ctx;
|
|
if (it != map.end()) {
|
|
ctx = it->second;
|
|
}
|
|
status
|
|
= merge(status, ret, ctx, stack.offset == stack.size() - 1 ? nullptr : stack[stack.offset]);
|
|
if (status < 0) {
|
|
break;
|
|
}
|
|
}
|
|
stack.offset = 0;
|
|
stack.back() = back;
|
|
return ret;
|
|
}
|
|
|
|
std::pair<bool, SoFCSelectionContextBasePtr*> SoFCSelectionRoot::findActionContext(
|
|
SoAction* action,
|
|
SoNode* _node,
|
|
bool create,
|
|
bool erase
|
|
)
|
|
{
|
|
std::pair<bool, SoFCSelectionContextBasePtr*> res(false, 0);
|
|
|
|
if (action->isOfType(SoSelectionElementAction::getClassTypeId())) {
|
|
res.first = static_cast<SoSelectionElementAction*>(action)->isSecondary();
|
|
}
|
|
|
|
auto it = ActionStacks.find(action);
|
|
if (it == ActionStacks.end() || it->second.empty()) {
|
|
return res;
|
|
}
|
|
|
|
auto& stack = it->second;
|
|
|
|
if (res.first) {
|
|
auto back = dynamic_cast<SoFCSelectionRoot*>(stack.back());
|
|
if (back != nullptr) {
|
|
stack.back() = _node;
|
|
if (create) {
|
|
res.second = &back->contextMap2[stack];
|
|
}
|
|
else {
|
|
auto it = back->contextMap2.find(stack);
|
|
if (it != back->contextMap2.end()) {
|
|
res.second = &it->second;
|
|
if (erase) {
|
|
back->contextMap2.erase(it);
|
|
}
|
|
}
|
|
}
|
|
stack.back() = back;
|
|
}
|
|
}
|
|
else {
|
|
auto front = dynamic_cast<SoFCSelectionRoot*>(stack.front());
|
|
if (front != nullptr) {
|
|
stack.front() = _node;
|
|
if (create) {
|
|
res.second = &front->contextMap[stack];
|
|
}
|
|
else {
|
|
auto it = front->contextMap.find(stack);
|
|
if (it != front->contextMap.end()) {
|
|
res.second = &it->second;
|
|
if (erase) {
|
|
front->contextMap.erase(it);
|
|
}
|
|
}
|
|
}
|
|
stack.front() = front;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
bool SoFCSelectionRoot::renderBBox(SoGLRenderAction* action, SoNode* node, SbColor color)
|
|
{
|
|
auto data = static_cast<SoFCBBoxRenderInfo*>(so_bbox_storage->get());
|
|
if (!data->bboxaction) {
|
|
// The viewport region will be replaced every time the action is
|
|
// used, so we can just feed it a dummy here.
|
|
data->bboxaction = new SoGetBoundingBoxAction(SbViewportRegion());
|
|
data->cube = new SoCube;
|
|
data->cube->ref();
|
|
data->packer = new SoColorPacker;
|
|
}
|
|
|
|
SbBox3f bbox;
|
|
data->bboxaction->setViewportRegion(action->getViewportRegion());
|
|
data->bboxaction->apply(node);
|
|
bbox = data->bboxaction->getBoundingBox();
|
|
if (bbox.isEmpty()) {
|
|
return false;
|
|
}
|
|
|
|
auto state = action->getState();
|
|
|
|
state->push();
|
|
|
|
SoMaterialBindingElement::set(state, SoMaterialBindingElement::OVERALL);
|
|
SoLazyElement::setEmissive(state, &color);
|
|
SoLazyElement::setDiffuse(state, node, 1, &color, data->packer);
|
|
SoDrawStyleElement::set(state, node, SoDrawStyleElement::LINES);
|
|
SoLineWidthElement::set(state, node, 1.0f);
|
|
|
|
const static float trans = 0.0;
|
|
SoLazyElement::setTransparency(state, node, 1, &trans, data->packer);
|
|
|
|
float x, y, z;
|
|
bbox.getSize(x, y, z);
|
|
data->cube->width = x + 0.001;
|
|
data->cube->height = y + 0.001;
|
|
data->cube->depth = z + 0.001;
|
|
|
|
SoModelMatrixElement::translateBy(state, node, bbox.getCenter());
|
|
|
|
SoMaterialBundle mb(action);
|
|
mb.sendFirst();
|
|
|
|
data->cube->GLRender(action);
|
|
|
|
state->pop();
|
|
return true;
|
|
}
|
|
|
|
static std::time_t _CyclicLastReported;
|
|
|
|
void SoFCSelectionRoot::renderPrivate(SoGLRenderAction* action, bool inPath)
|
|
{
|
|
if (ViewParams::instance()->getCoinCycleCheck() && !SelStack.nodeSet.insert(this).second) {
|
|
std::time_t t = std::time(nullptr);
|
|
if (_CyclicLastReported < t) {
|
|
_CyclicLastReported = t + 5;
|
|
FC_ERR("Cyclic scene graph: " << getName());
|
|
}
|
|
return;
|
|
}
|
|
SelStack.push_back(this);
|
|
if (_renderPrivate(action, inPath)) {
|
|
if (inPath) {
|
|
SoSeparator::GLRenderInPath(action);
|
|
}
|
|
else {
|
|
SoSeparator::GLRenderBelowPath(action);
|
|
}
|
|
}
|
|
SelStack.pop_back();
|
|
SelStack.nodeSet.erase(this);
|
|
}
|
|
|
|
bool SoFCSelectionRoot::_renderPrivate(SoGLRenderAction* action, bool inPath)
|
|
{
|
|
auto ctx2 = std::static_pointer_cast<SelContext>(
|
|
getNodeContext2(SelStack, this, SelContext::merge)
|
|
);
|
|
if (ctx2 && ctx2->hideAll) {
|
|
return false;
|
|
}
|
|
|
|
auto state = action->getState();
|
|
SelContextPtr ctx = getRenderContext<SelContext>(this);
|
|
int style = selectionStyle.getValue();
|
|
if ((style == SoFCSelectionRoot::Box || ViewParams::instance()->getShowSelectionBoundingBox())
|
|
&& ctx && !ctx->hideAll && (ctx->selAll || ctx->hlAll)) {
|
|
if (style == SoFCSelectionRoot::PassThrough) {
|
|
style = SoFCSelectionRoot::Box;
|
|
}
|
|
else {
|
|
renderBBox(action, this, ctx->hlAll ? ctx->hlColor : ctx->selColor);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Here, we are not setting (pre)selection color override here.
|
|
// Instead, we are checking and setting up for any secondary context
|
|
// color override.
|
|
//
|
|
// When the current selection style is full highlight, we should ignore any
|
|
// secondary override. If the style is bounding box, however, we should
|
|
// honour the secondary color override.
|
|
|
|
bool colorPushed = false;
|
|
if (!ShapeColorNode && overrideColor && !SoOverrideElement::getDiffuseColorOverride(state)
|
|
&& (style == SoFCSelectionRoot::Box || !ctx || (!ctx->selAll && !ctx->hideAll))) {
|
|
ShapeColorNode = this;
|
|
colorPushed = true;
|
|
state->push();
|
|
auto& packer = ShapeColorNode->shapeColorPacker;
|
|
auto& trans = ShapeColorNode->transOverride;
|
|
auto& color = ShapeColorNode->colorOverride;
|
|
if (!SoOverrideElement::getTransparencyOverride(state)) {
|
|
SoLazyElement::setTransparency(state, ShapeColorNode, 1, &trans, &packer);
|
|
SoOverrideElement::setTransparencyOverride(state, ShapeColorNode, true);
|
|
}
|
|
SoLazyElement::setDiffuse(state, ShapeColorNode, 1, &color, &packer);
|
|
SoOverrideElement::setDiffuseColorOverride(state, ShapeColorNode, true);
|
|
SoMaterialBindingElement::set(state, ShapeColorNode, SoMaterialBindingElement::OVERALL);
|
|
SoOverrideElement::setMaterialBindingOverride(state, ShapeColorNode, true);
|
|
|
|
SoTextureEnabledElement::set(state, ShapeColorNode, false);
|
|
}
|
|
|
|
if (!ctx) {
|
|
if (inPath) {
|
|
SoSeparator::GLRenderInPath(action);
|
|
}
|
|
else {
|
|
SoSeparator::GLRenderBelowPath(action);
|
|
}
|
|
}
|
|
else {
|
|
bool selPushed;
|
|
bool hlPushed;
|
|
if ((selPushed = ctx->selAll)) {
|
|
SelColorStack.push_back(ctx->selColor);
|
|
|
|
if (style != SoFCSelectionRoot::Box) {
|
|
state->push();
|
|
auto& color = SelColorStack.back();
|
|
SoLazyElement::setEmissive(state, &color);
|
|
SoOverrideElement::setEmissiveColorOverride(state, this, true);
|
|
if (SoLazyElement::getLightModel(state) == SoLazyElement::BASE_COLOR) {
|
|
auto& packer = shapeColorPacker;
|
|
SoLazyElement::setDiffuse(state, this, 1, &color, &packer);
|
|
SoOverrideElement::setDiffuseColorOverride(state, this, true);
|
|
SoMaterialBindingElement::set(state, this, SoMaterialBindingElement::OVERALL);
|
|
SoOverrideElement::setMaterialBindingOverride(state, this, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((hlPushed = ctx->hlAll)) {
|
|
HlColorStack.push_back(ctx->hlColor);
|
|
}
|
|
|
|
if (inPath) {
|
|
SoSeparator::GLRenderInPath(action);
|
|
}
|
|
else {
|
|
SoSeparator::GLRenderBelowPath(action);
|
|
}
|
|
|
|
if (selPushed) {
|
|
SelColorStack.pop_back();
|
|
|
|
if (style != SoFCSelectionRoot::Box) {
|
|
state->pop();
|
|
}
|
|
}
|
|
if (hlPushed) {
|
|
HlColorStack.pop_back();
|
|
}
|
|
}
|
|
|
|
if (colorPushed) {
|
|
ShapeColorNode = nullptr;
|
|
state->pop();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void SoFCSelectionRoot::GLRenderBelowPath(SoGLRenderAction* action)
|
|
{
|
|
renderPrivate(action, false);
|
|
}
|
|
|
|
void SoFCSelectionRoot::GLRenderInPath(SoGLRenderAction* action)
|
|
{
|
|
if (action->getCurPathCode() == SoAction::BELOW_PATH) {
|
|
return GLRenderBelowPath(action);
|
|
}
|
|
renderPrivate(action, true);
|
|
}
|
|
|
|
bool SoFCSelectionRoot::checkColorOverride(SoState* state)
|
|
{
|
|
if (ShapeColorNode) {
|
|
if (!SoOverrideElement::getDiffuseColorOverride(state)) {
|
|
state->push();
|
|
auto& packer = ShapeColorNode->shapeColorPacker;
|
|
auto& trans = ShapeColorNode->transOverride;
|
|
auto& color = ShapeColorNode->colorOverride;
|
|
if (!SoOverrideElement::getTransparencyOverride(state)) {
|
|
SoLazyElement::setTransparency(state, ShapeColorNode, 1, &trans, &packer);
|
|
SoOverrideElement::setTransparencyOverride(state, ShapeColorNode, true);
|
|
}
|
|
SoLazyElement::setDiffuse(state, ShapeColorNode, 1, &color, &packer);
|
|
SoOverrideElement::setDiffuseColorOverride(state, ShapeColorNode, true);
|
|
SoMaterialBindingElement::set(state, ShapeColorNode, SoMaterialBindingElement::OVERALL);
|
|
SoOverrideElement::setMaterialBindingOverride(state, ShapeColorNode, true);
|
|
|
|
SoTextureEnabledElement::set(state, ShapeColorNode, false);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SoFCSelectionRoot::checkSelection(bool& sel, SbColor& selColor, bool& hl, SbColor& hlColor)
|
|
{
|
|
sel = false;
|
|
hl = false;
|
|
if ((sel = !SelColorStack.empty())) {
|
|
selColor = SelColorStack.back();
|
|
}
|
|
if ((hl = !HlColorStack.empty())) {
|
|
hlColor = HlColorStack.back();
|
|
}
|
|
}
|
|
|
|
void SoFCSelectionRoot::resetContext()
|
|
{
|
|
contextMap.clear();
|
|
}
|
|
|
|
void SoFCSelectionRoot::moveActionStack(SoAction* from, SoAction* to, bool erase)
|
|
{
|
|
auto it = ActionStacks.find(from);
|
|
if (it == ActionStacks.end()) {
|
|
return;
|
|
}
|
|
auto& stack = ActionStacks[to];
|
|
assert(stack.empty());
|
|
stack.swap(it->second);
|
|
if (erase) {
|
|
ActionStacks.erase(it);
|
|
}
|
|
}
|
|
|
|
#define BEGIN_ACTION \
|
|
auto& stack = ActionStacks[action]; \
|
|
if (ViewParams::instance()->getCoinCycleCheck() && !stack.nodeSet.insert(this).second) { \
|
|
std::time_t t = std::time(0); \
|
|
if (_CyclicLastReported < t) { \
|
|
_CyclicLastReported = t + 5; \
|
|
FC_ERR("Cyclic scene graph: " << getName()); \
|
|
} \
|
|
return; \
|
|
} \
|
|
stack.push_back(this); \
|
|
auto size = stack.size();
|
|
|
|
#define END_ACTION \
|
|
if (stack.size() != size || stack.back() != this) \
|
|
FC_ERR("action stack fault"); \
|
|
else { \
|
|
stack.nodeSet.erase(this); \
|
|
stack.pop_back(); \
|
|
if (stack.empty()) \
|
|
ActionStacks.erase(action); \
|
|
}
|
|
|
|
void SoFCSelectionRoot::pick(SoPickAction* action)
|
|
{
|
|
BEGIN_ACTION;
|
|
if (doActionPrivate(stack, action)) {
|
|
inherited::pick(action);
|
|
}
|
|
END_ACTION;
|
|
}
|
|
|
|
void SoFCSelectionRoot::rayPick(SoRayPickAction* action)
|
|
{
|
|
BEGIN_ACTION;
|
|
if (doActionPrivate(stack, action)) {
|
|
inherited::rayPick(action);
|
|
}
|
|
END_ACTION;
|
|
}
|
|
|
|
void SoFCSelectionRoot::handleEvent(SoHandleEventAction* action)
|
|
{
|
|
BEGIN_ACTION;
|
|
inherited::handleEvent(action);
|
|
END_ACTION;
|
|
}
|
|
|
|
void SoFCSelectionRoot::search(SoSearchAction* action)
|
|
{
|
|
BEGIN_ACTION;
|
|
inherited::search(action);
|
|
END_ACTION;
|
|
}
|
|
|
|
void SoFCSelectionRoot::getPrimitiveCount(SoGetPrimitiveCountAction* action)
|
|
{
|
|
BEGIN_ACTION;
|
|
inherited::getPrimitiveCount(action);
|
|
END_ACTION;
|
|
}
|
|
|
|
void SoFCSelectionRoot::getBoundingBox(SoGetBoundingBoxAction* action)
|
|
{
|
|
BEGIN_ACTION;
|
|
if (doActionPrivate(stack, action)) {
|
|
inherited::getBoundingBox(action);
|
|
}
|
|
END_ACTION;
|
|
}
|
|
|
|
void SoFCSelectionRoot::getMatrix(SoGetMatrixAction* action)
|
|
{
|
|
BEGIN_ACTION;
|
|
if (doActionPrivate(stack, action)) {
|
|
inherited::getMatrix(action);
|
|
}
|
|
END_ACTION;
|
|
}
|
|
|
|
void SoFCSelectionRoot::callback(SoCallbackAction* action)
|
|
{
|
|
BEGIN_ACTION;
|
|
inherited::callback(action);
|
|
END_ACTION;
|
|
}
|
|
|
|
void SoFCSelectionRoot::doAction(SoAction* action)
|
|
{
|
|
BEGIN_ACTION
|
|
if (doActionPrivate(stack, action)) {
|
|
inherited::doAction(action);
|
|
}
|
|
END_ACTION
|
|
}
|
|
|
|
bool SoFCSelectionRoot::doActionPrivate(Stack& stack, SoAction* action)
|
|
{
|
|
// Selection action short-circuit optimization. In case of whole object
|
|
// selection/preselection, we shall store a SelContext keyed by ourself.
|
|
// And the action traversal can be short-curcuited once the first targeted
|
|
// SoFCSelectionRoot is found here. New function checkSelection() is exposed
|
|
// to check for whole object selection. This greatly improve performance on
|
|
// large group.
|
|
|
|
SelContextPtr ctx2;
|
|
bool ctx2Searched = false;
|
|
bool isTail = false;
|
|
if (action->getCurPathCode() == SoAction::IN_PATH) {
|
|
auto path = action->getPathAppliedTo();
|
|
if (path) {
|
|
isTail = path->getTail() == this
|
|
|| (path->getLength() > 1 && path->getNodeFromTail(1) == this
|
|
&& path->getTail()->isOfType(SoSwitch::getClassTypeId()));
|
|
}
|
|
|
|
if (!action->isOfType(SoSelectionElementAction::getClassTypeId())) {
|
|
ctx2Searched = true;
|
|
ctx2 = std::static_pointer_cast<SelContext>(
|
|
getNodeContext2(stack, this, SelContext::merge)
|
|
);
|
|
if (ctx2 && ctx2->hideAll) {
|
|
return false;
|
|
}
|
|
}
|
|
if (!isTail) {
|
|
return true;
|
|
}
|
|
}
|
|
else if (action->getWhatAppliedTo() != SoAction::NODE
|
|
&& action->getCurPathCode() != SoAction::BELOW_PATH) {
|
|
return true;
|
|
}
|
|
|
|
if (action->isOfType(SoSelectionElementAction::getClassTypeId())) {
|
|
auto selAction = static_cast<SoSelectionElementAction*>(action);
|
|
if (selAction->isSecondary()) {
|
|
if (selAction->getType() == SoSelectionElementAction::Show
|
|
|| (selAction->getType() == SoSelectionElementAction::Color
|
|
&& selAction->getColors().empty()
|
|
&& action->getWhatAppliedTo() == SoAction::NODE)) {
|
|
auto ctx = getActionContext(action, this, SelContextPtr(), false);
|
|
if (ctx && ctx->hideAll) {
|
|
ctx->hideAll = false;
|
|
if (!ctx->hlAll && !ctx->selAll) {
|
|
removeActionContext(action, this);
|
|
}
|
|
touch();
|
|
}
|
|
// applied to a node means clear all visibility setting, so
|
|
// return true to propagate the action
|
|
return selAction->getType() == SoSelectionElementAction::Color
|
|
|| action->getWhatAppliedTo() == SoAction::NODE;
|
|
}
|
|
else if (selAction->getType() == SoSelectionElementAction::Hide) {
|
|
if (action->getCurPathCode() == SoAction::BELOW_PATH || isTail) {
|
|
auto ctx = getActionContext(action, this, SelContextPtr());
|
|
if (ctx && !ctx->hideAll) {
|
|
ctx->hideAll = true;
|
|
touch();
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (selAction->getType() == SoSelectionElementAction::None) {
|
|
if (action->getWhatAppliedTo() == SoAction::NODE) {
|
|
// Here the 'select none' action is applied to a node, and we
|
|
// are the first SoFCSelectionRoot encountered (which means all
|
|
// children stores selection context here, both whole object
|
|
// and element selection), then we can simply perform the
|
|
// action by clearing the selection context here, and save the
|
|
// time for traversing a potentially large amount of children
|
|
// nodes.
|
|
resetContext();
|
|
touch();
|
|
return false;
|
|
}
|
|
|
|
auto ctx = getActionContext(action, this, SelContextPtr(), false);
|
|
if (ctx && ctx->selAll) {
|
|
ctx->selAll = false;
|
|
touch();
|
|
return false;
|
|
}
|
|
}
|
|
else if (selAction->getType() == SoSelectionElementAction::All) {
|
|
auto ctx = getActionContext(action, this, SelContextPtr());
|
|
assert(ctx);
|
|
ctx->selAll = true;
|
|
ctx->selColor = selAction->getColor();
|
|
touch();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (action->isOfType(SoHighlightElementAction::getClassTypeId())) {
|
|
auto highlightAction = static_cast<SoHighlightElementAction*>(action);
|
|
if (highlightAction->isHighlighted()) {
|
|
if (highlightAction->getElement()) {
|
|
auto ctx = getActionContext(action, this, SelContextPtr(), false);
|
|
if (ctx && ctx->hlAll) {
|
|
ctx->hlAll = false;
|
|
touch();
|
|
}
|
|
}
|
|
else {
|
|
auto ctx = getActionContext(action, this, SelContextPtr());
|
|
assert(ctx);
|
|
ctx->hlAll = true;
|
|
ctx->hlColor = highlightAction->getColor();
|
|
touch();
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
auto ctx = getActionContext(action, this, SelContextPtr(), false);
|
|
if (ctx && ctx->hlAll) {
|
|
ctx->hlAll = false;
|
|
touch();
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (!ctx2Searched) {
|
|
ctx2 = std::static_pointer_cast<SelContext>(getNodeContext2(stack, this, SelContext::merge));
|
|
if (ctx2 && ctx2->hideAll) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int SoFCSelectionRoot::SelContext::merge(
|
|
int status,
|
|
SoFCSelectionContextBasePtr& output,
|
|
SoFCSelectionContextBasePtr input,
|
|
SoNode*
|
|
)
|
|
{
|
|
auto ctx = std::dynamic_pointer_cast<SelContext>(input);
|
|
if (ctx && ctx->hideAll) {
|
|
output = ctx;
|
|
return -1;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
SO_NODE_SOURCE(SoFCPathAnnotation)
|
|
|
|
SoFCPathAnnotation::SoFCPathAnnotation()
|
|
{
|
|
SO_NODE_CONSTRUCTOR(SoFCPathAnnotation);
|
|
path = nullptr;
|
|
tmpPath = nullptr;
|
|
det = nullptr;
|
|
}
|
|
|
|
SoFCPathAnnotation::~SoFCPathAnnotation()
|
|
{
|
|
if (path) {
|
|
path->unref();
|
|
}
|
|
if (tmpPath) {
|
|
tmpPath->unref();
|
|
}
|
|
delete det;
|
|
}
|
|
|
|
void SoFCPathAnnotation::finish()
|
|
{
|
|
atexit_cleanup();
|
|
}
|
|
|
|
void SoFCPathAnnotation::initClass()
|
|
{
|
|
SO_NODE_INIT_CLASS(SoFCPathAnnotation, SoSeparator, "Separator");
|
|
}
|
|
|
|
void SoFCPathAnnotation::GLRender(SoGLRenderAction* action)
|
|
{
|
|
switch (action->getCurPathCode()) {
|
|
case SoAction::NO_PATH:
|
|
case SoAction::BELOW_PATH:
|
|
this->GLRenderBelowPath(action);
|
|
break;
|
|
case SoAction::OFF_PATH:
|
|
break;
|
|
case SoAction::IN_PATH:
|
|
this->GLRenderInPath(action);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void SoFCPathAnnotation::GLRenderBelowPath(SoGLRenderAction* action)
|
|
{
|
|
if (!path || !path->getLength() || !tmpPath || !tmpPath->getLength()) {
|
|
return;
|
|
}
|
|
|
|
if (path->getLength() != tmpPath->getLength()) {
|
|
// The auditing SoPath may be truncated due to harmless things such as
|
|
// flipping a SoSwitch sibling node. So we keep an unauditing SoTempPath
|
|
// around to try to restore the path.
|
|
for (int i = path->getLength() - 1; i < tmpPath->getLength() - 1; ++i) {
|
|
auto children = path->getNode(i)->getChildren();
|
|
if (children) {
|
|
int idx = children->find(tmpPath->getNode(i + 1));
|
|
if (idx >= 0) {
|
|
path->append(idx);
|
|
continue;
|
|
}
|
|
}
|
|
tmpPath->unref();
|
|
tmpPath = nullptr;
|
|
return;
|
|
}
|
|
}
|
|
|
|
SoState* state = action->getState();
|
|
SoGLCacheContextElement::shouldAutoCache(state, SoGLCacheContextElement::DONT_AUTO_CACHE);
|
|
|
|
if (action->isRenderingDelayedPaths()) {
|
|
SbBool zbenabled = glIsEnabled(GL_DEPTH_TEST);
|
|
if (zbenabled) {
|
|
glDisable(GL_DEPTH_TEST);
|
|
}
|
|
|
|
if (det) {
|
|
inherited::GLRenderInPath(action);
|
|
}
|
|
else {
|
|
bool bbox = ViewParams::instance()->getShowSelectionBoundingBox();
|
|
if (!bbox) {
|
|
for (int i = 0, count = path->getLength(); i < count; ++i) {
|
|
if (!path->getNode(i)->isOfType(SoFCSelectionRoot::getClassTypeId())) {
|
|
continue;
|
|
}
|
|
auto node = dynamic_cast<SoFCSelectionRoot*>(path->getNode(i));
|
|
if (node != nullptr && node->selectionStyle.getValue() == SoFCSelectionRoot::Box) {
|
|
bbox = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!bbox) {
|
|
inherited::GLRenderInPath(action);
|
|
}
|
|
else {
|
|
bool sel = false;
|
|
bool hl = false;
|
|
SbColor selColor, hlColor;
|
|
SoFCSelectionRoot::checkSelection(sel, selColor, hl, hlColor);
|
|
if (sel || hl) {
|
|
SoFCSelectionRoot::renderBBox(action, this, hl ? hlColor : selColor);
|
|
}
|
|
else {
|
|
inherited::GLRenderInPath(action);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (zbenabled) {
|
|
glEnable(GL_DEPTH_TEST);
|
|
}
|
|
}
|
|
else {
|
|
SoCacheElement::invalidate(action->getState());
|
|
auto curPath = action->getCurPath();
|
|
auto newPath = new SoPath(curPath->getLength() + path->getLength());
|
|
newPath->append(curPath);
|
|
newPath->append(path);
|
|
action->addDelayedPath(newPath);
|
|
}
|
|
}
|
|
|
|
void SoFCPathAnnotation::GLRenderInPath(SoGLRenderAction* action)
|
|
{
|
|
GLRenderBelowPath(action);
|
|
}
|
|
|
|
void SoFCPathAnnotation::setDetail(SoDetail* d)
|
|
{
|
|
if (d != det) {
|
|
delete det;
|
|
det = d;
|
|
}
|
|
}
|
|
|
|
void SoFCPathAnnotation::setPath(SoPath* newPath)
|
|
{
|
|
if (path) {
|
|
path->unref();
|
|
coinRemoveAllChildren(this);
|
|
path = nullptr;
|
|
if (tmpPath) {
|
|
tmpPath->unref();
|
|
tmpPath = nullptr;
|
|
}
|
|
}
|
|
if (!newPath || !newPath->getLength()) {
|
|
return;
|
|
}
|
|
|
|
tmpPath = new SoTempPath(newPath->getLength());
|
|
tmpPath->ref();
|
|
for (int i = 0; i < newPath->getLength(); ++i) {
|
|
tmpPath->append(newPath->getNode(i));
|
|
}
|
|
path = newPath->copy();
|
|
path->ref();
|
|
addChild(path->getNode(0));
|
|
}
|
|
|
|
void SoFCPathAnnotation::getBoundingBox(SoGetBoundingBoxAction* action)
|
|
{
|
|
if (path) {
|
|
SoGetBoundingBoxAction bboxAction(action->getViewportRegion());
|
|
SoFCSelectionRoot::moveActionStack(action, &bboxAction, false);
|
|
bboxAction.apply(path);
|
|
SoFCSelectionRoot::moveActionStack(&bboxAction, action, true);
|
|
auto bbox = bboxAction.getBoundingBox();
|
|
if (!bbox.isEmpty()) {
|
|
action->extendBy(bbox);
|
|
}
|
|
}
|
|
}
|