FreeCAD / src /Gui /Navigation /SiemensNXNavigationStyle.cpp

Upload folder using huggingface_hub

985c397 verified 9 months ago

16 kB

// SPDX-License-Identifier: LGPL-2.1-or-later

/***************************************************************************
 *   Copyright (c) 2025 Werner Mayer <wmayer[at]users.sourceforge.net>     *
 *                                                                         *
 *   This file is part of FreeCAD.                                         *
 *                                                                         *
 *   FreeCAD is free software: you can redistribute it and/or modify it    *
 *   under the terms of the GNU Lesser General Public License as           *
 *   published by the Free Software Foundation, either version 2.1 of the  *
 *   License, or (at your option) any later version.                       *
 *                                                                         *
 *   FreeCAD 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      *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with FreeCAD. If not, see                               *
 *   <https://www.gnu.org/licenses/>.                                      *
 *                                                                         *
 **************************************************************************/

#include <QApplication>

#include <boost/statechart/custom_reaction.hpp>
#include <boost/statechart/state_machine.hpp>
#include <boost/statechart/state.hpp>

#include "Camera.h"
#include "SiemensNXNavigationStyle.h"
#include "View3DInventorViewer.h"

// NOLINTBEGIN(cppcoreguidelines-pro-type-static-cast-downcast,
//             cppcoreguidelines-avoid*,
//             readability-avoid-const-params-in-decls)
using namespace Gui;
namespace sc = boost::statechart;
using SC = NavigationStateChart;
using NS = SiemensNXNavigationStyle;

struct NS::NaviMachine: public sc::state_machine<NS::NaviMachine, NS::IdleState>
{
    using superclass = sc::state_machine<NS::NaviMachine, NS::IdleState>;
    explicit NaviMachine(NS& ns)
        : ns(ns)
    {}
    NS& ns;
};

struct NS::IdleState: public sc::state<NS::IdleState, NS::NaviMachine>
{
    using reactions = sc::custom_reaction<SC::Event>;
    explicit IdleState(my_context ctx)
        : my_base(ctx)
    {
        auto& ns = this->outermost_context().ns;
        ns.setViewingMode(NavigationStyle::IDLE);
    }
    sc::result react(const SC::Event& ev)
    {
        auto& ns = this->outermost_context().ns;
        switch (ns.getViewingMode()) {
            case NavigationStyle::SEEK_WAIT_MODE: {
                if (ev.isPress(SoMouseButtonEvent::BUTTON1)) {
                    ns.seekToPoint(ev.inventor_event->getPosition());
                    ns.setViewingMode(NavigationStyle::SEEK_MODE);
                    ev.flags->processed = true;
                    return transit<NS::AwaitingReleaseState>();
                }
                break;
            }
            case NavigationStyle::SPINNING:
            case NavigationStyle::SEEK_MODE: {
                if (!ev.flags->processed) {
                    if (ev.isMouseButtonEvent()) {
                        ev.flags->processed = true;
                        return transit<NS::AwaitingReleaseState>();
                    }
                    else if (ev.isKeyboardEvent() || ev.isMotion3Event()) {
                        ns.setViewingMode(NavigationStyle::IDLE);
                    }
                }

                break;
            }
            case NavigationStyle::BOXZOOM:
                return forward_event();
        }

        // right-click
        if (ev.isRelease(SoMouseButtonEvent::BUTTON2) && ev.mbstate() == 0
            && !ns.viewer->isEditing() && ns.isPopupMenuEnabled()) {
            ns.openPopupMenu(ev.inventor_event->getPosition());
        }

        if (ev.isPress(SoMouseButtonEvent::BUTTON3)) {
            if (ev.isDownShift()) {
                ev.flags->processed = true;
                return transit<NS::PanState>();
            }

            if (ev.isDownButton(SC::Event::BUTTON3DOWN)) {
                ev.flags->processed = true;
                return transit<NS::AwaitingMoveState>();
            }
        }

        // Use processClickEvent()

        // Implement selection callback
        // if (ev.isLocation2Event() && ev.isDownButton1()) {
        //    ev.flags->processed = true;
        //    return transit<NS::SelectionState>();
        //}

        return forward_event();
    }
};

struct NS::AwaitingReleaseState: public sc::state<NS::AwaitingReleaseState, NS::NaviMachine>
{
    using reactions = sc::custom_reaction<NS::Event>;
    explicit AwaitingReleaseState(my_context ctx)
        : my_base(ctx)
    {}

    sc::result react(const NS::Event& /*ev*/)
    {
        return forward_event();
    }
};

struct NS::InteractState: public sc::state<NS::InteractState, NS::NaviMachine>
{
    using reactions = sc::custom_reaction<NS::Event>;
    explicit InteractState(my_context ctx)
        : my_base(ctx)
    {
        auto& ns = this->outermost_context().ns;
        ns.setViewingMode(NavigationStyle::INTERACT);
    }

    sc::result react(const NS::Event& /*ev*/)
    {
        return forward_event();
    }
};

struct NS::AwaitingMoveState: public sc::state<NS::AwaitingMoveState, NS::NaviMachine>
{
    using reactions = sc::custom_reaction<NS::Event>;

private:
    SbVec2s base_pos;
    SbTime since;

public:
    explicit AwaitingMoveState(my_context ctx)
        : my_base(ctx)
    {
        auto& ns = this->outermost_context().ns;
        ns.setViewingMode(NavigationStyle::DRAGGING);
        this->base_pos
            = static_cast<const NS::Event*>(this->triggering_event())->inventor_event->getPosition();
        this->since
            = static_cast<const NS::Event*>(this->triggering_event())->inventor_event->getTime();
    }
    sc::result react(const NS::Event& ev)
    {
        // this state consumes all mouse events.
        ev.flags->processed = ev.isMouseButtonEvent() || ev.isLocation2Event();

        if (ev.isLocation2Event()) {
            return transit<NS::RotateState>();
        }

        // right-click
        if (ev.isPress(SoMouseButtonEvent::BUTTON2) && ev.isDownButton3()) {
            return transit<NS::PanState>();
        }

        if (ev.isKeyPress(SoKeyboardEvent::LEFT_SHIFT)) {
            ev.flags->processed = true;
            return transit<NS::PanState>();
        }

        // left-click
        if (ev.isPress(SoMouseButtonEvent::BUTTON1) && ev.isDownButton3()) {
            return transit<NS::ZoomState>();
        }

        if (ev.isKeyPress(SoKeyboardEvent::LEFT_CONTROL)) {
            ev.flags->processed = true;
            return transit<NS::ZoomState>();
        }

        // middle-click
        if (ev.isRelease(SoMouseButtonEvent::BUTTON3) && ev.isDownNoButton()) {
            auto& ns = this->outermost_context().ns;
            SbTime tmp = (ev.inventor_event->getTime() - this->since);
            double dci = QApplication::doubleClickInterval() / 1000.0;

            // is this a simple middle click?
            if (tmp.getValue() < dci) {
                ev.flags->processed = true;
                SbVec2s pos = ev.inventor_event->getPosition();
                ns.lookAtPoint(pos);
            }
            return transit<NS::IdleState>();
        }

        return forward_event();
    }
};

struct NS::RotateState: public sc::state<NS::RotateState, NS::NaviMachine>
{
    using reactions = sc::custom_reaction<NS::Event>;
    explicit RotateState(my_context ctx)
        : my_base(ctx)
    {
        auto& ns = this->outermost_context().ns;
        const auto inventorEvent
            = static_cast<const NS::Event*>(this->triggering_event())->inventor_event;
        ns.saveCursorPosition(inventorEvent);
        ns.setViewingMode(NavigationStyle::DRAGGING);
        this->base_pos = inventorEvent->getPosition();
    }

    sc::result react(const NS::Event& ev)
    {
        if (ev.isLocation2Event()) {
            auto& ns = this->outermost_context().ns;
            ns.addToLog(ev.inventor_event->getPosition(), ev.inventor_event->getTime());
            const SbVec2s pos = ev.inventor_event->getPosition();
            const SbVec2f posn = ns.normalizePixelPos(pos);
            ns.spin(posn);
            ns.moveCursorPosition();
            ev.flags->processed = true;
        }

        // right-click
        if (ev.isPress(SoMouseButtonEvent::BUTTON2) && ev.isDownButton3()) {
            ev.flags->processed = true;
            return transit<NS::PanState>();
        }

        if (ev.isKeyPress(SoKeyboardEvent::LEFT_SHIFT)) {
            ev.flags->processed = true;
            return transit<NS::PanState>();
        }

        // left-click
        if (ev.isPress(SoMouseButtonEvent::BUTTON1) && ev.isDownButton3()) {
            ev.flags->processed = true;
            return transit<NS::ZoomState>();
        }

        if (ev.isKeyPress(SoKeyboardEvent::LEFT_CONTROL)) {
            ev.flags->processed = true;
            return transit<NS::ZoomState>();
        }

        if (ev.isRelease(SoMouseButtonEvent::BUTTON3) && ev.isDownNoButton()) {
            ev.flags->processed = true;
            return transit<NS::IdleState>();
        }
        return forward_event();
    }

private:
    SbVec2s base_pos;
};

struct NS::PanState: public sc::state<NS::PanState, NS::NaviMachine>
{
    using reactions = sc::custom_reaction<NS::Event>;
    explicit PanState(my_context ctx)
        : my_base(ctx)
    {
        auto& ns = this->outermost_context().ns;
        const NS::Event* ev = static_cast<const NS::Event*>(this->triggering_event());
        ns.setViewingMode(NavigationStyle::PANNING);
        this->base_pos = ev->inventor_event->getPosition();
        this->ratio = ns.viewer->getSoRenderManager()->getViewportRegion().getViewportAspectRatio();
        ns.centerTime = ev->inventor_event->getTime();
        ns.setupPanningPlane(ns.getCamera());
    }
    sc::result react(const NS::Event& ev)
    {
        if (ev.isLocation2Event()) {
            ev.flags->processed = true;
            SbVec2s pos = ev.inventor_event->getPosition();
            auto& ns = this->outermost_context().ns;
            ns.panCamera(
                ns.viewer->getSoRenderManager()->getCamera(),
                this->ratio,
                ns.panningplane,
                ns.normalizePixelPos(pos),
                ns.normalizePixelPos(this->base_pos)
            );
            this->base_pos = pos;
        }

        if (ev.isRelease(SoMouseButtonEvent::BUTTON2) && ev.isDownButton3()) {
            ev.flags->processed = true;
            return transit<NS::RotateState>();
        }

        if (ev.isKeyRelease(SoKeyboardEvent::LEFT_SHIFT) && ev.isDownButton3()) {
            ev.flags->processed = true;
            return transit<NS::RotateState>();
        }

        if (ev.isRelease(SoMouseButtonEvent::BUTTON3)) {
            ev.flags->processed = true;
            return transit<NS::IdleState>();
        }

        return forward_event();
    }

private:
    SbVec2s base_pos;
    float ratio {1.0F};
};

struct NS::ZoomState: public sc::state<NS::ZoomState, NS::NaviMachine>
{
    using reactions = sc::custom_reaction<NS::Event>;
    explicit ZoomState(my_context ctx)
        : my_base(ctx)
    {
        auto& ns = this->outermost_context().ns;
        const NS::Event* ev = static_cast<const NS::Event*>(this->triggering_event());
        ns.setViewingMode(NavigationStyle::ZOOMING);
        this->base_pos = ev->inventor_event->getPosition();
    }

    sc::result react(const NS::Event& ev)
    {
        if (ev.isLocation2Event()) {
            ev.flags->processed = true;
            SbVec2s pos = ev.inventor_event->getPosition();
            auto& ns = this->outermost_context().ns;
            ns.zoomByCursor(ns.normalizePixelPos(pos), ns.normalizePixelPos(this->base_pos));
            this->base_pos = pos;
        }

        if (ev.isRelease(SoMouseButtonEvent::BUTTON1) && ev.isDownButton3()) {
            ev.flags->processed = true;
            return transit<NS::RotateState>();
        }

        if (ev.isKeyRelease(SoKeyboardEvent::LEFT_CONTROL) && ev.isDownButton3()) {
            ev.flags->processed = true;
            return transit<NS::RotateState>();
        }

        if (ev.isRelease(SoMouseButtonEvent::BUTTON3)) {
            ev.flags->processed = true;
            return transit<NS::IdleState>();
        }

        return forward_event();
    }

private:
    SbVec2s base_pos;
};

struct NS::SelectionState: public sc::state<NS::SelectionState, NS::NaviMachine>
{
    using reactions = sc::custom_reaction<NS::Event>;
    explicit SelectionState(my_context ctx)
        : my_base(ctx)
    {
        auto& ns = this->outermost_context().ns;
        const NS::Event* ev = static_cast<const NS::Event*>(this->triggering_event());

        ns.setViewingMode(NavigationStyle::BOXZOOM);
        ns.startSelection(NavigationStyle::Rubberband);
        fakeLeftButtonDown(ev->inventor_event->getPosition());
    }

    void fakeLeftButtonDown(const SbVec2s& pos)
    {
        SoMouseButtonEvent mbe;
        mbe.setButton(SoMouseButtonEvent::BUTTON1);
        mbe.setState(SoMouseButtonEvent::DOWN);
        mbe.setPosition(pos);

        auto& ns = this->outermost_context().ns;
        ns.processEvent(&mbe);
    }

    sc::result react(const NS::Event& /*ev*/)
    {
        // This isn't called while selection mode is active
        return transit<NS::IdleState>();
    }
};

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

/* TRANSLATOR Gui::SiemensNXNavigationStyle */

TYPESYSTEM_SOURCE(Gui::SiemensNXNavigationStyle, Gui::UserNavigationStyle)

SiemensNXNavigationStyle::SiemensNXNavigationStyle()
{
    naviMachine.reset(new NaviStateMachineT(new NaviMachine(*this)));
}

SiemensNXNavigationStyle::~SiemensNXNavigationStyle()
{}

const char* SiemensNXNavigationStyle::mouseButtons(ViewerMode mode)
{
    switch (mode) {
        case NavigationStyle::SELECTION:
            return QT_TR_NOOP("Press left mouse button");
        case NavigationStyle::PANNING:
            return QT_TR_NOOP("Press middle+right click");
        case NavigationStyle::DRAGGING:
            return QT_TR_NOOP("Press middle mouse button");
        case NavigationStyle::ZOOMING:
            return QT_TR_NOOP("Scroll mouse wheel");
        default:
            return "No description";
    }
}

std::string SiemensNXNavigationStyle::userFriendlyName() const
{
    return {"Siemens NX"};
}

SbBool SiemensNXNavigationStyle::processKeyboardEvent(const SoKeyboardEvent* const event)
{
    // See https://forum.freecad.org/viewtopic.php?t=96459
    // Isometric view: Home key button
    // Trimetric view: End key button
    // Fit all: CTRL+F
    // Normal view: F8
    switch (event->getKey()) {
        case SoKeyboardEvent::F:
            if (event->wasCtrlDown()) {
                viewer->viewAll();
                return true;
            }
            break;
        case SoKeyboardEvent::HOME: {
            viewer->setCameraOrientation(Camera::rotation(Camera::Isometric));
            return true;
        }
        case SoKeyboardEvent::END: {
            viewer->setCameraOrientation(Camera::rotation(Camera::Trimetric));
            return true;
        }
        case SoKeyboardEvent::F8: {
            viewer->setCameraOrientation(Camera::rotation(Camera::Top));
            return true;
        }
        default:
            break;
    }

    return inherited::processKeyboardEvent(event);
}

// NOLINTEND(cppcoreguidelines-pro-type-static-cast-downcast,
//           cppcoreguidelines-avoid*,
//           readability-avoid-const-params-in-decls)

	// SPDX-License-Identifier: LGPL-2.1-or-later

	/***************************************************************************
	* Copyright (c) 2025 Werner Mayer <wmayer[at]users.sourceforge.net> *
	* *
	* This file is part of FreeCAD. *
	* *
	* FreeCAD is free software: you can redistribute it and/or modify it *
	* under the terms of the GNU Lesser General Public License as *
	* published by the Free Software Foundation, either version 2.1 of the *
	* License, or (at your option) any later version. *
	* *
	* FreeCAD 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 *
	* Lesser General Public License for more details. *
	* *
	* You should have received a copy of the GNU Lesser General Public *
	* License along with FreeCAD. If not, see *
	* <https://www.gnu.org/licenses/>. *
	* *
	**************************************************************************/

	#include <QApplication>

	#include <boost/statechart/custom_reaction.hpp>
	#include <boost/statechart/state_machine.hpp>
	#include <boost/statechart/state.hpp>

	#include "Camera.h"
	#include "SiemensNXNavigationStyle.h"
	#include "View3DInventorViewer.h"

	// NOLINTBEGIN(cppcoreguidelines-pro-type-static-cast-downcast,
	// cppcoreguidelines-avoid*,
	// readability-avoid-const-params-in-decls)
	using namespace Gui;
	namespace sc = boost::statechart;
	using SC = NavigationStateChart;
	using NS = SiemensNXNavigationStyle;

	struct NS::NaviMachine: public sc::state_machine<NS::NaviMachine, NS::IdleState>
	{
	using superclass = sc::state_machine<NS::NaviMachine, NS::IdleState>;
	explicit NaviMachine(NS& ns)
	: ns(ns)
	{}
	NS& ns;
	};

	struct NS::IdleState: public sc::state<NS::IdleState, NS::NaviMachine>
	{
	using reactions = sc::custom_reaction<SC::Event>;
	explicit IdleState(my_context ctx)
	: my_base(ctx)
	{
	auto& ns = this->outermost_context().ns;
	ns.setViewingMode(NavigationStyle::IDLE);
	}
	sc::result react(const SC::Event& ev)
	{
	auto& ns = this->outermost_context().ns;
	switch (ns.getViewingMode()) {
	case NavigationStyle::SEEK_WAIT_MODE: {
	if (ev.isPress(SoMouseButtonEvent::BUTTON1)) {
	ns.seekToPoint(ev.inventor_event->getPosition());
	ns.setViewingMode(NavigationStyle::SEEK_MODE);
	ev.flags->processed = true;
	return transit<NS::AwaitingReleaseState>();
	}
	break;
	}
	case NavigationStyle::SPINNING:
	case NavigationStyle::SEEK_MODE: {
	if (!ev.flags->processed) {
	if (ev.isMouseButtonEvent()) {
	ev.flags->processed = true;
	return transit<NS::AwaitingReleaseState>();
	}
	else if (ev.isKeyboardEvent() \|\| ev.isMotion3Event()) {
	ns.setViewingMode(NavigationStyle::IDLE);
	}
	}

	break;
	}
	case NavigationStyle::BOXZOOM:
	return forward_event();
	}

	// right-click
	if (ev.isRelease(SoMouseButtonEvent::BUTTON2) && ev.mbstate() == 0
	&& !ns.viewer->isEditing() && ns.isPopupMenuEnabled()) {
	ns.openPopupMenu(ev.inventor_event->getPosition());
	}

	if (ev.isPress(SoMouseButtonEvent::BUTTON3)) {
	if (ev.isDownShift()) {
	ev.flags->processed = true;
	return transit<NS::PanState>();
	}

	if (ev.isDownButton(SC::Event::BUTTON3DOWN)) {
	ev.flags->processed = true;
	return transit<NS::AwaitingMoveState>();
	}
	}

	// Use processClickEvent()

	// Implement selection callback
	// if (ev.isLocation2Event() && ev.isDownButton1()) {
	// ev.flags->processed = true;
	// return transit<NS::SelectionState>();
	//}

	return forward_event();
	}
	};

	struct NS::AwaitingReleaseState: public sc::state<NS::AwaitingReleaseState, NS::NaviMachine>
	{
	using reactions = sc::custom_reaction<NS::Event>;
	explicit AwaitingReleaseState(my_context ctx)
	: my_base(ctx)
	{}

	sc::result react(const NS::Event& /ev/)
	{
	return forward_event();
	}
	};

	struct NS::InteractState: public sc::state<NS::InteractState, NS::NaviMachine>
	{
	using reactions = sc::custom_reaction<NS::Event>;
	explicit InteractState(my_context ctx)
	: my_base(ctx)
	{
	auto& ns = this->outermost_context().ns;
	ns.setViewingMode(NavigationStyle::INTERACT);
	}

	sc::result react(const NS::Event& /ev/)
	{
	return forward_event();
	}
	};

	struct NS::AwaitingMoveState: public sc::state<NS::AwaitingMoveState, NS::NaviMachine>
	{
	using reactions = sc::custom_reaction<NS::Event>;

	private:
	SbVec2s base_pos;
	SbTime since;

	public:
	explicit AwaitingMoveState(my_context ctx)
	: my_base(ctx)
	{
	auto& ns = this->outermost_context().ns;
	ns.setViewingMode(NavigationStyle::DRAGGING);
	this->base_pos
	= static_cast<const NS::Event*>(this->triggering_event())->inventor_event->getPosition();
	this->since
	= static_cast<const NS::Event*>(this->triggering_event())->inventor_event->getTime();
	}
	sc::result react(const NS::Event& ev)
	{
	// this state consumes all mouse events.
	ev.flags->processed = ev.isMouseButtonEvent() \|\| ev.isLocation2Event();

	if (ev.isLocation2Event()) {
	return transit<NS::RotateState>();
	}

	// right-click
	if (ev.isPress(SoMouseButtonEvent::BUTTON2) && ev.isDownButton3()) {
	return transit<NS::PanState>();
	}

	if (ev.isKeyPress(SoKeyboardEvent::LEFT_SHIFT)) {
	ev.flags->processed = true;
	return transit<NS::PanState>();
	}

	// left-click
	if (ev.isPress(SoMouseButtonEvent::BUTTON1) && ev.isDownButton3()) {
	return transit<NS::ZoomState>();
	}

	if (ev.isKeyPress(SoKeyboardEvent::LEFT_CONTROL)) {
	ev.flags->processed = true;
	return transit<NS::ZoomState>();
	}

	// middle-click
	if (ev.isRelease(SoMouseButtonEvent::BUTTON3) && ev.isDownNoButton()) {
	auto& ns = this->outermost_context().ns;
	SbTime tmp = (ev.inventor_event->getTime() - this->since);
	double dci = QApplication::doubleClickInterval() / 1000.0;

	// is this a simple middle click?
	if (tmp.getValue() < dci) {
	ev.flags->processed = true;
	SbVec2s pos = ev.inventor_event->getPosition();
	ns.lookAtPoint(pos);
	}
	return transit<NS::IdleState>();
	}

	return forward_event();
	}
	};

	struct NS::RotateState: public sc::state<NS::RotateState, NS::NaviMachine>
	{
	using reactions = sc::custom_reaction<NS::Event>;
	explicit RotateState(my_context ctx)
	: my_base(ctx)
	{
	auto& ns = this->outermost_context().ns;
	const auto inventorEvent
	= static_cast<const NS::Event*>(this->triggering_event())->inventor_event;
	ns.saveCursorPosition(inventorEvent);
	ns.setViewingMode(NavigationStyle::DRAGGING);
	this->base_pos = inventorEvent->getPosition();
	}

	sc::result react(const NS::Event& ev)
	{
	if (ev.isLocation2Event()) {
	auto& ns = this->outermost_context().ns;
	ns.addToLog(ev.inventor_event->getPosition(), ev.inventor_event->getTime());
	const SbVec2s pos = ev.inventor_event->getPosition();
	const SbVec2f posn = ns.normalizePixelPos(pos);
	ns.spin(posn);
	ns.moveCursorPosition();
	ev.flags->processed = true;
	}

	// right-click
	if (ev.isPress(SoMouseButtonEvent::BUTTON2) && ev.isDownButton3()) {
	ev.flags->processed = true;
	return transit<NS::PanState>();
	}

	if (ev.isKeyPress(SoKeyboardEvent::LEFT_SHIFT)) {
	ev.flags->processed = true;
	return transit<NS::PanState>();
	}

	// left-click
	if (ev.isPress(SoMouseButtonEvent::BUTTON1) && ev.isDownButton3()) {
	ev.flags->processed = true;
	return transit<NS::ZoomState>();
	}

	if (ev.isKeyPress(SoKeyboardEvent::LEFT_CONTROL)) {
	ev.flags->processed = true;
	return transit<NS::ZoomState>();
	}

	if (ev.isRelease(SoMouseButtonEvent::BUTTON3) && ev.isDownNoButton()) {
	ev.flags->processed = true;
	return transit<NS::IdleState>();
	}
	return forward_event();
	}

	private:
	SbVec2s base_pos;
	};

	struct NS::PanState: public sc::state<NS::PanState, NS::NaviMachine>
	{
	using reactions = sc::custom_reaction<NS::Event>;
	explicit PanState(my_context ctx)
	: my_base(ctx)
	{
	auto& ns = this->outermost_context().ns;
	const NS::Event* ev = static_cast<const NS::Event*>(this->triggering_event());
	ns.setViewingMode(NavigationStyle::PANNING);
	this->base_pos = ev->inventor_event->getPosition();
	this->ratio = ns.viewer->getSoRenderManager()->getViewportRegion().getViewportAspectRatio();
	ns.centerTime = ev->inventor_event->getTime();
	ns.setupPanningPlane(ns.getCamera());
	}
	sc::result react(const NS::Event& ev)
	{
	if (ev.isLocation2Event()) {
	ev.flags->processed = true;
	SbVec2s pos = ev.inventor_event->getPosition();
	auto& ns = this->outermost_context().ns;
	ns.panCamera(
	ns.viewer->getSoRenderManager()->getCamera(),
	this->ratio,
	ns.panningplane,
	ns.normalizePixelPos(pos),
	ns.normalizePixelPos(this->base_pos)
	);
	this->base_pos = pos;
	}

	if (ev.isRelease(SoMouseButtonEvent::BUTTON2) && ev.isDownButton3()) {
	ev.flags->processed = true;
	return transit<NS::RotateState>();
	}

	if (ev.isKeyRelease(SoKeyboardEvent::LEFT_SHIFT) && ev.isDownButton3()) {
	ev.flags->processed = true;
	return transit<NS::RotateState>();
	}

	if (ev.isRelease(SoMouseButtonEvent::BUTTON3)) {
	ev.flags->processed = true;
	return transit<NS::IdleState>();
	}

	return forward_event();
	}

	private:
	SbVec2s base_pos;
	float ratio {1.0F};
	};

	struct NS::ZoomState: public sc::state<NS::ZoomState, NS::NaviMachine>
	{
	using reactions = sc::custom_reaction<NS::Event>;
	explicit ZoomState(my_context ctx)
	: my_base(ctx)
	{
	auto& ns = this->outermost_context().ns;
	const NS::Event* ev = static_cast<const NS::Event*>(this->triggering_event());
	ns.setViewingMode(NavigationStyle::ZOOMING);
	this->base_pos = ev->inventor_event->getPosition();
	}

	sc::result react(const NS::Event& ev)
	{
	if (ev.isLocation2Event()) {
	ev.flags->processed = true;
	SbVec2s pos = ev.inventor_event->getPosition();
	auto& ns = this->outermost_context().ns;
	ns.zoomByCursor(ns.normalizePixelPos(pos), ns.normalizePixelPos(this->base_pos));
	this->base_pos = pos;
	}

	if (ev.isRelease(SoMouseButtonEvent::BUTTON1) && ev.isDownButton3()) {
	ev.flags->processed = true;
	return transit<NS::RotateState>();
	}

	if (ev.isKeyRelease(SoKeyboardEvent::LEFT_CONTROL) && ev.isDownButton3()) {
	ev.flags->processed = true;
	return transit<NS::RotateState>();
	}

	if (ev.isRelease(SoMouseButtonEvent::BUTTON3)) {
	ev.flags->processed = true;
	return transit<NS::IdleState>();
	}

	return forward_event();
	}

	private:
	SbVec2s base_pos;
	};

	struct NS::SelectionState: public sc::state<NS::SelectionState, NS::NaviMachine>
	{
	using reactions = sc::custom_reaction<NS::Event>;
	explicit SelectionState(my_context ctx)
	: my_base(ctx)
	{
	auto& ns = this->outermost_context().ns;
	const NS::Event* ev = static_cast<const NS::Event*>(this->triggering_event());

	ns.setViewingMode(NavigationStyle::BOXZOOM);
	ns.startSelection(NavigationStyle::Rubberband);
	fakeLeftButtonDown(ev->inventor_event->getPosition());
	}

	void fakeLeftButtonDown(const SbVec2s& pos)
	{
	SoMouseButtonEvent mbe;
	mbe.setButton(SoMouseButtonEvent::BUTTON1);
	mbe.setState(SoMouseButtonEvent::DOWN);
	mbe.setPosition(pos);

	auto& ns = this->outermost_context().ns;
	ns.processEvent(&mbe);
	}

	sc::result react(const NS::Event& /ev/)
	{
	// This isn't called while selection mode is active
	return transit<NS::IdleState>();
	}
	};

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

	/* TRANSLATOR Gui::SiemensNXNavigationStyle */

	TYPESYSTEM_SOURCE(Gui::SiemensNXNavigationStyle, Gui::UserNavigationStyle)

	SiemensNXNavigationStyle::SiemensNXNavigationStyle()
	{
	naviMachine.reset(new NaviStateMachineT(new NaviMachine(*this)));
	}

	SiemensNXNavigationStyle::~SiemensNXNavigationStyle()
	{}

	const char* SiemensNXNavigationStyle::mouseButtons(ViewerMode mode)
	{
	switch (mode) {
	case NavigationStyle::SELECTION:
	return QT_TR_NOOP("Press left mouse button");
	case NavigationStyle::PANNING:
	return QT_TR_NOOP("Press middle+right click");
	case NavigationStyle::DRAGGING:
	return QT_TR_NOOP("Press middle mouse button");
	case NavigationStyle::ZOOMING:
	return QT_TR_NOOP("Scroll mouse wheel");
	default:
	return "No description";
	}
	}

	std::string SiemensNXNavigationStyle::userFriendlyName() const
	{
	return {"Siemens NX"};
	}

	SbBool SiemensNXNavigationStyle::processKeyboardEvent(const SoKeyboardEvent* const event)
	{
	// See https://forum.freecad.org/viewtopic.php?t=96459
	// Isometric view: Home key button
	// Trimetric view: End key button
	// Fit all: CTRL+F
	// Normal view: F8
	switch (event->getKey()) {
	case SoKeyboardEvent::F:
	if (event->wasCtrlDown()) {
	viewer->viewAll();
	return true;
	}
	break;
	case SoKeyboardEvent::HOME: {
	viewer->setCameraOrientation(Camera::rotation(Camera::Isometric));
	return true;
	}
	case SoKeyboardEvent::END: {
	viewer->setCameraOrientation(Camera::rotation(Camera::Trimetric));
	return true;
	}
	case SoKeyboardEvent::F8: {
	viewer->setCameraOrientation(Camera::rotation(Camera::Top));
	return true;
	}
	default:
	break;
	}

	return inherited::processKeyboardEvent(event);
	}

	// NOLINTEND(cppcoreguidelines-pro-type-static-cast-downcast,
	// cppcoreguidelines-avoid*,
	// readability-avoid-const-params-in-decls)