OpenCMT/uLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor using pimpl and fix test

Browse Source
This commit is contained in:
AndreaRigoni
2026-03-25 16:18:07 +00:00
parent a467b7385b
commit 7d4acaef6d
17 changed files with 479 additions and 412 deletions
Download Patch File Download Diff File Expand all files Collapse all files

305
src/Vtk/vtkHandlerWidget.cpp
View File

@@ -25,6 +25,7 @@
#include "vtkHandlerWidget.h"
#include <iostream>
#include <vtkActor.h>
#include <vtkArcSource.h>
#include <vtkArrowSource.h>
#include <vtkCallbackCommand.h>
@@ -51,32 +52,60 @@
namespace uLib {
namespace Vtk {
struct HandlerWidgetData {
vtkSmartPointer<::vtkRenderer> m_OverlayRenderer;
::vtkProp *m_HighlightedProp;
// Visual components //
vtkSmartPointer<::vtkActor> m_AxesX, m_AxesY, m_AxesZ; // Arrows
vtkSmartPointer<::vtkActor> m_RotX, m_RotY, m_RotZ; // Rings
vtkSmartPointer<::vtkActor> m_RotCam; // Camera ring
vtkSmartPointer<::vtkActor> m_ScaleX, m_ScaleY, m_ScaleZ; // Cubes
vtkSmartPointer<::vtkPlane> m_ClipPlane;
vtkSmartPointer<::vtkCellPicker> m_Picker;
vtkSmartPointer<::vtkTransform> m_InitialTransform;
std::vector<vtkSmartPointer<::vtkTransform>> m_TransformChain;
vtkSmartPointer<::vtkMatrix4x4> m_BaseMatrix;
HandlerWidgetData() {
m_Picker = vtkSmartPointer<::vtkCellPicker>::New();
m_InitialTransform = vtkSmartPointer<::vtkTransform>::New();
m_ClipPlane = vtkSmartPointer<::vtkPlane>::New();
m_OverlayRenderer = vtkSmartPointer<::vtkRenderer>::New();
m_BaseMatrix = vtkSmartPointer<::vtkMatrix4x4>::New();
m_HighlightedProp = nullptr;
}
};
vtkStandardNewMacro(vtkHandlerWidget);
vtkHandlerWidget::vtkHandlerWidget() {
vtkHandlerWidget::vtkHandlerWidget() : d(new HandlerWidgetData()) {
this->Interaction = IDLE;
this->m_Picker = vtkSmartPointer<::vtkCellPicker>::New();
this->m_Picker->SetTolerance(0.01); // Increased tolerance for thin gizmos
this->m_InitialTransform = vtkSmartPointer<::vtkTransform>::New();
d->m_Picker->SetTolerance(0.01); // Increased tolerance for thin gizmos
this->EventCallbackCommand->SetCallback(vtkHandlerWidget::ProcessEvents);
this->EventCallbackCommand->SetClientData(this);
this->m_Frame = LOCAL;
this->m_HighlightedProp = nullptr;
this->m_ClipPlane = vtkSmartPointer<::vtkPlane>::New();
this->m_OverlayRenderer = vtkSmartPointer<::vtkRenderer>::New();
this->m_OverlayRenderer->SetLayer(1);
this->m_OverlayRenderer->EraseOff();
this->m_OverlayRenderer->InteractiveOff();
d->m_OverlayRenderer->SetLayer(1);
d->m_OverlayRenderer->EraseOff();
d->m_OverlayRenderer->InteractiveOff();
this->Priority = 50.0; // Higher priority to beat camera style
this->m_TranslationEnabled = true;
this->m_RotationEnabled = true;
this->m_ScalingEnabled = true;
this->m_BaseMatrix = vtkSmartPointer<::vtkMatrix4x4>::New();
this->m_BaseMatrix->Identity();
d->m_BaseMatrix->Identity();
this->CreateGizmos();
}
vtkHandlerWidget::~vtkHandlerWidget() {}
vtkHandlerWidget::~vtkHandlerWidget() {
delete d;
}
::vtkRenderer *vtkHandlerWidget::GetOverlayRenderer() {
return d->m_OverlayRenderer;
}
void vtkHandlerWidget::SetProp3D(::vtkProp3D *prop) {
if (this->Prop3D == prop) {
@@ -84,13 +113,13 @@ void vtkHandlerWidget::SetProp3D(::vtkProp3D *prop) {
}
this->Prop3D = prop;
if (this->Prop3D) {
// Initialize m_BaseMatrix from the object's current matrix
// Initialize d->m_BaseMatrix from the object's current matrix
if (this->Prop3D->GetUserMatrix()) {
this->m_BaseMatrix->DeepCopy(this->Prop3D->GetUserMatrix());
this->d->m_BaseMatrix->DeepCopy(this->Prop3D->GetUserMatrix());
} else {
this->m_BaseMatrix->Identity();
this->d->m_BaseMatrix->Identity();
}
this->m_TransformChain.clear(); // Clear any previous transform chain
this->d->m_TransformChain.clear(); // Clear any previous transform chain
this->UpdateGizmoPosition();
}
this->Modified();
@@ -141,20 +170,20 @@ void vtkHandlerWidget::SetEnabled(int enabling) {
}
// Sync Viewport and Camera
this->m_OverlayRenderer->SetViewport(this->CurrentRenderer->GetViewport());
this->m_OverlayRenderer->SetActiveCamera(this->CurrentRenderer->GetActiveCamera());
win->AddRenderer(this->m_OverlayRenderer);
this->d->m_OverlayRenderer->SetViewport(this->CurrentRenderer->GetViewport());
this->d->m_OverlayRenderer->SetActiveCamera(this->CurrentRenderer->GetActiveCamera());
win->AddRenderer(this->d->m_OverlayRenderer);
this->m_OverlayRenderer->AddActor(m_AxesX);
this->m_OverlayRenderer->AddActor(m_AxesY);
this->m_OverlayRenderer->AddActor(m_AxesZ);
this->m_OverlayRenderer->AddActor(m_RotX);
this->m_OverlayRenderer->AddActor(m_RotY);
this->m_OverlayRenderer->AddActor(m_RotZ);
this->m_OverlayRenderer->AddActor(m_RotCam);
this->m_OverlayRenderer->AddActor(m_ScaleX);
this->m_OverlayRenderer->AddActor(m_ScaleY);
this->m_OverlayRenderer->AddActor(m_ScaleZ);
this->d->m_OverlayRenderer->AddActor(d->m_AxesX);
this->d->m_OverlayRenderer->AddActor(d->m_AxesY);
this->d->m_OverlayRenderer->AddActor(d->m_AxesZ);
this->d->m_OverlayRenderer->AddActor(d->m_RotX);
this->d->m_OverlayRenderer->AddActor(d->m_RotY);
this->d->m_OverlayRenderer->AddActor(d->m_RotZ);
this->d->m_OverlayRenderer->AddActor(d->m_RotCam);
this->d->m_OverlayRenderer->AddActor(d->m_ScaleX);
this->d->m_OverlayRenderer->AddActor(d->m_ScaleY);
this->d->m_OverlayRenderer->AddActor(d->m_ScaleZ);
this->UpdateVisibility();
@@ -167,9 +196,9 @@ void vtkHandlerWidget::SetEnabled(int enabling) {
this->Highlight(nullptr);
this->Interactor->RemoveObserver(this->EventCallbackCommand);
if (this->Interactor->GetRenderWindow()) {
this->Interactor->GetRenderWindow()->RemoveRenderer(this->m_OverlayRenderer);
this->Interactor->GetRenderWindow()->RemoveRenderer(this->d->m_OverlayRenderer);
}
this->m_OverlayRenderer->RemoveAllViewProps();
this->d->m_OverlayRenderer->RemoveAllViewProps();
this->InvokeEvent(::vtkCommand::DisableEvent, nullptr);
}
@@ -214,15 +243,15 @@ void vtkHandlerWidget::OnKeyPress() {
bool ctrl = (this->Interactor->GetControlKey() != 0);
if (ctrl && key == "z") {
if (!this->m_TransformChain.empty()) {
if (!this->d->m_TransformChain.empty()) {
std::cout << "Undoing last transform action..." << std::endl;
this->m_TransformChain.pop_back();
this->d->m_TransformChain.pop_back();
// Update object from chain
vtkNew<vtkTransform> total;
total->PostMultiply();
total->SetMatrix(this->m_BaseMatrix.GetPointer());
for (auto& t : m_TransformChain) {
total->SetMatrix(this->d->m_BaseMatrix.GetPointer());
for (auto& t : d->m_TransformChain) {
total->Concatenate(t);
}
@@ -245,33 +274,33 @@ void vtkHandlerWidget::OnLeftButtonDown() {
this->CurrentRenderer = this->Interactor->FindPokedRenderer(X, Y);
}
this->m_Picker->Pick(X, Y, 0.0, this->m_OverlayRenderer);
::vtkProp *prop = this->m_Picker->GetViewProp();
this->m_Picker->GetPickPosition(this->m_StartPickPosition);
this->d->m_Picker->Pick(X, Y, 0.0, this->d->m_OverlayRenderer);
::vtkProp *prop = this->d->m_Picker->GetViewProp();
this->d->m_Picker->GetPickPosition(this->m_StartPickPosition);
if (!prop)
return;
this->Interaction = IDLE;
if (prop == m_AxesX)
if (prop == d->m_AxesX)
this->Interaction = TRANS_X;
else if (prop == m_AxesY)
else if (prop == d->m_AxesY)
this->Interaction = TRANS_Y;
else if (prop == m_AxesZ)
else if (prop == d->m_AxesZ)
this->Interaction = TRANS_Z;
else if (prop == m_RotX)
else if (prop == d->m_RotX)
this->Interaction = ROT_X;
else if (prop == m_RotY)
else if (prop == d->m_RotY)
this->Interaction = ROT_Y;
else if (prop == m_RotZ)
else if (prop == d->m_RotZ)
this->Interaction = ROT_Z;
else if (prop == m_ScaleX)
else if (prop == d->m_ScaleX)
this->Interaction = SCALE_X;
else if (prop == m_ScaleY)
else if (prop == d->m_ScaleY)
this->Interaction = SCALE_Y;
else if (prop == m_ScaleZ)
else if (prop == d->m_ScaleZ)
this->Interaction = SCALE_Z;
else if (prop == m_RotCam)
else if (prop == d->m_RotCam)
this->Interaction = ROT_CAM;
if (this->Interaction != IDLE) {
@@ -285,14 +314,14 @@ void vtkHandlerWidget::OnLeftButtonDown() {
// If the chain is empty, initialize base from current state?
// Actually, if we just started selecting this object, we should have initialized BaseMatrix.
// For now, let's keep m_InitialTransform as the state BEFORE this drag
// For now, let's keep d->m_InitialTransform as the state BEFORE this drag
vtkNew<vtkTransform> current;
current->PostMultiply();
current->SetMatrix(this->m_BaseMatrix.GetPointer());
for (auto& t : m_TransformChain) {
current->SetMatrix(this->d->m_BaseMatrix.GetPointer());
for (auto& t : d->m_TransformChain) {
current->Concatenate(t);
}
this->m_InitialTransform->SetMatrix(current->GetMatrix());
this->d->m_InitialTransform->SetMatrix(current->GetMatrix());
}
this->EventCallbackCommand->SetAbortFlag(1);
this->InvokeEvent(::vtkCommand::StartInteractionEvent, nullptr);
@@ -310,10 +339,10 @@ void vtkHandlerWidget::OnLeftButtonUp() {
// We need to re-calculate the final 'op' to store it
// Actually, we could have stored it in OnMouseMove, but let's re-calculate or
// just capture the delta between m_InitialTransform and current UserMatrix.
// just capture the delta between d->m_InitialTransform and current UserMatrix.
if (this->Prop3D && this->Prop3D->GetUserMatrix()) {
vtkNew<vtkMatrix4x4> inv;
vtkMatrix4x4::Invert(this->m_InitialTransform->GetMatrix(), inv);
vtkMatrix4x4::Invert(this->d->m_InitialTransform->GetMatrix(), inv);
vtkNew<vtkMatrix4x4> final_op_mat;
vtkMatrix4x4::Multiply4x4(this->Prop3D->GetUserMatrix(), inv, final_op_mat);
@@ -321,8 +350,8 @@ void vtkHandlerWidget::OnLeftButtonUp() {
vtkNew<vtkTransform> final_op;
final_op->SetMatrix(final_op_mat);
this->m_TransformChain.push_back(final_op);
std::cout << "Action finalized. Chain size: " << this->m_TransformChain.size() << std::endl;
this->d->m_TransformChain.push_back(final_op);
std::cout << "Action finalized. Chain size: " << this->d->m_TransformChain.size() << std::endl;
}
this->Interaction = IDLE;
@@ -339,8 +368,8 @@ void vtkHandlerWidget::OnMouseMove() {
int Y = this->Interactor->GetEventPosition()[1];
if (this->Interaction == IDLE) {
this->m_Picker->Pick(X, Y, 0.0, this->m_OverlayRenderer);
::vtkProp *prop = this->m_Picker->GetViewProp();
this->d->m_Picker->Pick(X, Y, 0.0, this->d->m_OverlayRenderer);
::vtkProp *prop = this->d->m_Picker->GetViewProp();
this->Highlight(prop);
this->UpdateGizmoPosition(); // Ensure camera adjustments happen
return;
@@ -353,7 +382,7 @@ void vtkHandlerWidget::OnMouseMove() {
// std::cout << "Interaction " << this->Interaction << " dx=" << dx << " dy=" << dy << std::endl;
// Get current gizmo properties from its actors
vtkMatrix4x4 *gizmo_mat = m_AxesX->GetUserMatrix();
vtkMatrix4x4 *gizmo_mat = d->m_AxesX->GetUserMatrix();
if (!gizmo_mat)
return;
@@ -542,7 +571,7 @@ void vtkHandlerWidget::OnMouseMove() {
// Total transform = Base * Chain * Interaction
vtkNew<vtkTransform> total;
total->PostMultiply();
total->SetMatrix(this->m_InitialTransform->GetMatrix()); // m_InitialTransform is already Base*Chain
total->SetMatrix(this->d->m_InitialTransform->GetMatrix()); // d->m_InitialTransform is already Base*Chain
total->Concatenate(op);
vtkMatrix4x4* targetMat = this->Prop3D->GetUserMatrix();
@@ -588,41 +617,41 @@ void vtkHandlerWidget::SetScalingEnabled(bool enabled) {
}
void vtkHandlerWidget::UpdateVisibility() {
if (!m_AxesX) return;
if (!d->m_AxesX) return;
m_AxesX->SetVisibility(m_TranslationEnabled);
m_AxesY->SetVisibility(m_TranslationEnabled);
m_AxesZ->SetVisibility(m_TranslationEnabled);
d->m_AxesX->SetVisibility(m_TranslationEnabled);
d->m_AxesY->SetVisibility(m_TranslationEnabled);
d->m_AxesZ->SetVisibility(m_TranslationEnabled);
m_RotX->SetVisibility(m_RotationEnabled);
m_RotY->SetVisibility(m_RotationEnabled);
m_RotZ->SetVisibility(m_RotationEnabled);
m_RotCam->SetVisibility(m_RotationEnabled);
d->m_RotX->SetVisibility(m_RotationEnabled);
d->m_RotY->SetVisibility(m_RotationEnabled);
d->m_RotZ->SetVisibility(m_RotationEnabled);
d->m_RotCam->SetVisibility(m_RotationEnabled);
m_ScaleX->SetVisibility(m_ScalingEnabled);
m_ScaleY->SetVisibility(m_ScalingEnabled);
m_ScaleZ->SetVisibility(m_ScalingEnabled);
d->m_ScaleX->SetVisibility(m_ScalingEnabled);
d->m_ScaleY->SetVisibility(m_ScalingEnabled);
d->m_ScaleZ->SetVisibility(m_ScalingEnabled);
// Update picker list
if (m_Picker) {
m_Picker->InitializePickList();
if (d->m_Picker) {
d->m_Picker->InitializePickList();
if (m_TranslationEnabled) {
m_Picker->AddPickList(m_AxesX);
m_Picker->AddPickList(m_AxesY);
m_Picker->AddPickList(m_AxesZ);
d->m_Picker->AddPickList(d->m_AxesX);
d->m_Picker->AddPickList(d->m_AxesY);
d->m_Picker->AddPickList(d->m_AxesZ);
}
if (m_RotationEnabled) {
m_Picker->AddPickList(m_RotX);
m_Picker->AddPickList(m_RotY);
m_Picker->AddPickList(m_RotZ);
m_Picker->AddPickList(m_RotCam);
d->m_Picker->AddPickList(d->m_RotX);
d->m_Picker->AddPickList(d->m_RotY);
d->m_Picker->AddPickList(d->m_RotZ);
d->m_Picker->AddPickList(d->m_RotCam);
}
if (m_ScalingEnabled) {
m_Picker->AddPickList(m_ScaleX);
m_Picker->AddPickList(m_ScaleY);
m_Picker->AddPickList(m_ScaleZ);
d->m_Picker->AddPickList(d->m_ScaleX);
d->m_Picker->AddPickList(d->m_ScaleY);
d->m_Picker->AddPickList(d->m_ScaleZ);
}
m_Picker->PickFromListOn();
d->m_Picker->PickFromListOn();
}
}
@@ -676,7 +705,7 @@ void vtkHandlerWidget::CreateGizmos() {
auto mapper = vtkSmartPointer<::vtkPolyDataMapper>::New();
mapper->SetInputConnection(circle->GetOutputPort());
mapper->AddClippingPlane(this->m_ClipPlane);
mapper->AddClippingPlane(this->d->m_ClipPlane);
auto actor = vtkSmartPointer<::vtkActor>::New();
actor->SetMapper(mapper);
@@ -690,15 +719,15 @@ void vtkHandlerWidget::CreateGizmos() {
blue[] = {0.0, 0.0, 1.0}, white[] = {1.0, 1.0, 1.0};
double x[] = {1, 0, 0}, y[] = {0, 1, 0}, z[] = {0, 0, 1};
m_AxesX = create_arrow(x, red);
m_AxesY = create_arrow(y, green);
m_AxesZ = create_arrow(z, blue);
d->m_AxesX = create_arrow(x, red);
d->m_AxesY = create_arrow(y, green);
d->m_AxesZ = create_arrow(z, blue);
m_RotX = create_ring(0, red);
m_RotY = create_ring(1, green);
m_RotZ = create_ring(2, blue);
d->m_RotX = create_ring(0, red);
d->m_RotY = create_ring(1, green);
d->m_RotZ = create_ring(2, blue);
m_RotCam = vtkSmartPointer<::vtkActor>::New();
d->m_RotCam = vtkSmartPointer<::vtkActor>::New();
{
auto circle = vtkSmartPointer<::vtkRegularPolygonSource>::New();
circle->SetNumberOfSides(64);
@@ -708,10 +737,10 @@ void vtkHandlerWidget::CreateGizmos() {
circle->GeneratePolylineOn();
auto mapper = vtkSmartPointer<::vtkPolyDataMapper>::New();
mapper->SetInputConnection(circle->GetOutputPort());
m_RotCam->SetMapper(mapper);
m_RotCam->GetProperty()->SetColor(white);
m_RotCam->GetProperty()->SetLineWidth(2);
m_RotCam->GetProperty()->SetLighting(0);
d->m_RotCam->SetMapper(mapper);
d->m_RotCam->GetProperty()->SetColor(white);
d->m_RotCam->GetProperty()->SetLineWidth(2);
d->m_RotCam->GetProperty()->SetLighting(0);
}
auto create_cube = [](double pos[3], double color[3]) {
@@ -730,23 +759,23 @@ void vtkHandlerWidget::CreateGizmos() {
};
double px[] = {1.2, 0, 0}, py[] = {0, 1.2, 0}, pz[] = {0, 0, 1.2};
m_ScaleX = create_cube(px, red);
m_ScaleY = create_cube(py, green);
m_ScaleZ = create_cube(pz, blue);
d->m_ScaleX = create_cube(px, red);
d->m_ScaleY = create_cube(py, green);
d->m_ScaleZ = create_cube(pz, blue);
// Configure picker to only see gizmo actors (Pick-Through)
m_Picker->InitializePickList();
m_Picker->AddPickList(m_AxesX);
m_Picker->AddPickList(m_AxesY);
m_Picker->AddPickList(m_AxesZ);
m_Picker->AddPickList(m_RotX);
m_Picker->AddPickList(m_RotY);
m_Picker->AddPickList(m_RotZ);
m_Picker->AddPickList(m_RotCam);
m_Picker->AddPickList(m_ScaleX);
m_Picker->AddPickList(m_ScaleY);
m_Picker->AddPickList(m_ScaleZ);
m_Picker->PickFromListOn();
d->m_Picker->InitializePickList();
d->m_Picker->AddPickList(d->m_AxesX);
d->m_Picker->AddPickList(d->m_AxesY);
d->m_Picker->AddPickList(d->m_AxesZ);
d->m_Picker->AddPickList(d->m_RotX);
d->m_Picker->AddPickList(d->m_RotY);
d->m_Picker->AddPickList(d->m_RotZ);
d->m_Picker->AddPickList(d->m_RotCam);
d->m_Picker->AddPickList(d->m_ScaleX);
d->m_Picker->AddPickList(d->m_ScaleY);
d->m_Picker->AddPickList(d->m_ScaleZ);
d->m_Picker->PickFromListOn();
}
void vtkHandlerWidget::UpdateGizmoPosition() {
@@ -843,24 +872,24 @@ void vtkHandlerWidget::UpdateGizmoPosition() {
}
}
m_AxesX->SetUserMatrix(mat_gizmo);
m_AxesY->SetUserMatrix(mat_gizmo);
m_AxesZ->SetUserMatrix(mat_gizmo);
m_RotX->SetUserMatrix(mat_gizmo);
m_RotY->SetUserMatrix(mat_gizmo);
m_RotZ->SetUserMatrix(mat_gizmo);
m_ScaleX->SetUserMatrix(mat_gizmo);
m_ScaleY->SetUserMatrix(mat_gizmo);
m_ScaleZ->SetUserMatrix(mat_gizmo);
d->m_AxesX->SetUserMatrix(mat_gizmo);
d->m_AxesY->SetUserMatrix(mat_gizmo);
d->m_AxesZ->SetUserMatrix(mat_gizmo);
d->m_RotX->SetUserMatrix(mat_gizmo);
d->m_RotY->SetUserMatrix(mat_gizmo);
d->m_RotZ->SetUserMatrix(mat_gizmo);
d->m_ScaleX->SetUserMatrix(mat_gizmo);
d->m_ScaleY->SetUserMatrix(mat_gizmo);
d->m_ScaleZ->SetUserMatrix(mat_gizmo);
// Sync Overlay Renderer with Main Renderer
if (this->CurrentRenderer && this->m_OverlayRenderer) {
this->m_OverlayRenderer->SetViewport(this->CurrentRenderer->GetViewport());
this->m_OverlayRenderer->SetAspect(this->CurrentRenderer->GetAspect());
this->m_OverlayRenderer->ComputeAspect();
if (this->CurrentRenderer && this->d->m_OverlayRenderer) {
this->d->m_OverlayRenderer->SetViewport(this->CurrentRenderer->GetViewport());
this->d->m_OverlayRenderer->SetAspect(this->CurrentRenderer->GetAspect());
this->d->m_OverlayRenderer->ComputeAspect();
if (this->m_OverlayRenderer->GetActiveCamera() != this->CurrentRenderer->GetActiveCamera()) {
this->m_OverlayRenderer->SetActiveCamera(this->CurrentRenderer->GetActiveCamera());
if (this->d->m_OverlayRenderer->GetActiveCamera() != this->CurrentRenderer->GetActiveCamera()) {
this->d->m_OverlayRenderer->SetActiveCamera(this->CurrentRenderer->GetActiveCamera());
}
}
@@ -890,36 +919,36 @@ void vtkHandlerWidget::UpdateGizmoPosition() {
}
tcam->Translate(mat_gizmo->GetElement(0, 3), mat_gizmo->GetElement(1, 3),
mat_gizmo->GetElement(2, 3));
m_RotCam->SetUserMatrix(tcam->GetMatrix());
d->m_RotCam->SetUserMatrix(tcam->GetMatrix());
// Update clipping plane for axes rings
this->m_ClipPlane->SetOrigin(mat_gizmo->GetElement(0, 3),
this->d->m_ClipPlane->SetOrigin(mat_gizmo->GetElement(0, 3),
mat_gizmo->GetElement(1, 3),
mat_gizmo->GetElement(2, 3));
this->m_ClipPlane->SetNormal(dir);
this->d->m_ClipPlane->SetNormal(dir);
}
}
void vtkHandlerWidget::Highlight(::vtkProp *prop) {
if (this->m_HighlightedProp == prop)
if (this->d->m_HighlightedProp == prop)
return;
// Restore previous
if (this->m_HighlightedProp) {
::vtkActor *actor = ::vtkActor::SafeDownCast(this->m_HighlightedProp);
if (this->d->m_HighlightedProp) {
::vtkActor *actor = ::vtkActor::SafeDownCast(this->d->m_HighlightedProp);
if (actor) {
actor->GetProperty()->SetColor(m_OriginalColor);
actor->GetProperty()->SetLineWidth(3);
}
}
this->m_HighlightedProp = nullptr;
this->d->m_HighlightedProp = nullptr;
// Highlight new if it belongs to us
if (prop == m_AxesX || prop == m_AxesY || prop == m_AxesZ || prop == m_RotX ||
prop == m_RotY || prop == m_RotZ || prop == m_RotCam || prop == m_ScaleX ||
prop == m_ScaleY || prop == m_ScaleZ) {
this->m_HighlightedProp = prop;
if (prop == d->m_AxesX || prop == d->m_AxesY || prop == d->m_AxesZ || prop == d->m_RotX ||
prop == d->m_RotY || prop == d->m_RotZ || prop == d->m_RotCam || prop == d->m_ScaleX ||
prop == d->m_ScaleY || prop == d->m_ScaleZ) {
this->d->m_HighlightedProp = prop;
::vtkActor *actor = ::vtkActor::SafeDownCast(prop);
if (actor) {
actor->GetProperty()->GetColor(m_OriginalColor);