mouseControl.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
 
//! \file
//! \brief Mouse control handling with focus detection and state management
 
#pragma once
 
#include "vreInput/export.h"
 
#include "vrePlayerStation/vreEventProcessor.h"
#include "vreMessageManager/vreMessage.h"
 
// Disable Boost signals to allow Qt signals
 
#include <QtCore/QObject>
 
namespace makVre
{
//! \brief Helper class to detect and monitor window focus changes
//!
//! This Qt-based class monitors focus changes in application windows and
//! notifies the mouse control system when focus state changes occur.
//! This enables proper handling of mouse input when the application loses focus.
class VREINPUT_DLL DtMouseControlFocusWatcher : public QObject
{
   Q_OBJECT
public:
   //! \brief Constructor that initializes focus watching
   //!
   //! Sets up the focus watcher with the given display environment and
   //! connects to the Qt signal for application focus changes.
   //!
   //! \param de Reference to the display environment
   DtMouseControlFocusWatcher(makVrv::DtDe& de);
 
   //! \brief Destructor
   //!
   //! Cleans up focus watcher resources
   virtual ~DtMouseControlFocusWatcher() override;
 
   //! \brief Check and update the application focus state
   //!
   //! Determines if the application window has focus and sends a message
   //! if the focus state has changed since the last check.
   void updateFocusState();
 
private:
   //! \brief Reference to the display environment
   makVrv::DtDe& myDe;
 
   //! \brief Connection to Qt's focus changed signal
   QMetaObject::Connection myFocusChangedConnection;
 
   //! \brief Flag indicating if a widget within the application has focus
   bool myWidgetInFocus;
 
   //! \brief Current focus state of the application
   bool myFocusState;
};
 
 
//! \brief Manages mouse control state and behavior
//!
//! This class implements configurable mouse control with focus awareness.
//! It provides functionality to toggle mouse control on/off, handle focus changes,
//! and manage mouse centering. It integrates with the message system to respond
//! to system-wide state changes that affect mouse behavior.
class VREINPUT_DLL DtMouseControl
{
public:
   //! \brief Constructor that initializes mouse control
   //!
   //! Sets up the mouse control system with the given display environment.
   //!
   //! \param de Reference to the display environment
   DtMouseControl(makVrv::DtDe& de);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources owned by the mouse control system
   virtual ~DtMouseControl();
 
   //! \brief Initialize the mouse control system
   //!
   //! Sets up message handlers and initializes the mouse control state.
   //!
   //! \return True if initialization succeeded, false otherwise
   virtual bool init();
 
   //! \brief Shut down the mouse control system
   //!
   //! Unregisters message handlers and cleans up resources allocated during initialization
   virtual void shutdown();
 
   //! \brief Check if mouse control is currently enabled
   //!
   //! \return True if mouse control is enabled, false otherwise
   virtual bool isEnabled() const;
 
   //! \brief Check if the application window has focus
   //!
   //! \return True if the application has focus, false otherwise
   virtual bool isFocused() const;
 
   //! \brief Center the mouse cursor in the application window
   //!
   //! Positions the mouse cursor at the center of the current viewport
   virtual void centerMouse();
 
   //! \brief Get the current input channel
   //!
   //! Returns the channel used for mouse input events
   //!
   //! \return Pointer to the current input channel
   makVrv::DtChannel* getChannel() const;
 
protected:
   //! \brief Update the mouse control state based on current system state
   //!
   //! Evaluates focus state, toggle state, and player controls state to determine
   //! whether mouse control should be enabled or disabled
   virtual void updateMouseControlState();
   //! \brief Handle message to toggle mouse control on or off
   //!
   //! Message handler that toggles the mouse control state when requested
   //!
   //! \param msg Pointer to the toggle mouse control message
   //! \return Result indicating whether the message was handled
   virtual DtVreMessageResult handleToggleMouseControl(DtVreMessage* msg);
   //! \brief Handle message indicating player controls state change
   //!
   //! Message handler that updates mouse control in response to player controls state changes
   //!
   //! \param msg Pointer to the player controls state message
   //! \return Result indicating whether the message was handled
   virtual DtVreMessageResult handlePlayerControlsState(DtVreMessage* msg);
   //! \brief Handle message indicating focus state change
   //!
   //! Message handler that updates mouse control in response to window focus changes
   //!
   //! \param msg Pointer to the focus state message
   //! \return Result indicating whether the message was handled
   virtual DtVreMessageResult handleFocusState(DtVreMessage* msg);
 
   //! \brief Update the input channel for mouse events
   //!
   //! Sets or updates the channel used for mouse input events based on
   //! window and channel names
   //!
   //! \param windowName Name of the window to associate with the channel
   //! \param channelName Name of the channel to use
   virtual void updateChannel(const std::string& windowName = "", const std::string& channelName = "");
 
   //! \brief Focus watcher for detecting window focus changes
   DtMouseControlFocusWatcher myMouseControlFocusWatcher;
 
   //! \brief Reference to the display environment
   makVrv::DtDe& myDe;
 
   //! \brief Pointer to the current input channel
   makVrv::DtChannel* myChannel;
 
   //! \brief Flag indicating if mouse control is currently enabled
   bool myEnabled;
 
   //! \brief Flag indicating if mouse control is toggled on by the user
   //!
   //! When true, mouse control should be enabled if system state allows it
   bool myIsToggledOn;
 
   //! \brief Flag indicating if player controls are enabled
   bool myPlayerControlsEnabled;
 
   //! \brief Flag indicating if application has focus
   bool myHasFocus;
};
 
} // namespace makVre