vreSelectConnectionPageDriver.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreSelectConnectionPageDriver.h
//! \brief Defines the base class for connection drivers in VR-Engage
//!
//! This file contains the DtVreSelectConnectionPageDriver class which serves as
//! the base class for specific connection protocol drivers (DIS, HLA) in the
//! VR-Engage connection system. It provides common properties and functionality
//! for connection drivers, including name, type, auto-connect, and active state.
 
#pragma once
 
#include <vrePlayerStation/export.h>
 
#include "vreMessageManager/vreMessage.h"
 
#include <QObject>
 
class QQuickItem;
 
namespace makVre
{
//! \brief Base class for connection drivers in the connection selection UI
//!
//! DtVreSelectConnectionPageDriver serves as the abstract base class for specific
//! connection protocol drivers (such as DIS or HLA) in the VR-Engage connection system.
//! It provides common properties like driver name, type, auto-connect state, and active
//! connection state that are shared across all driver implementations. This class
//! exposes these properties to QML for the connection selection UI, and handles
//! updates to the backend connection system when the properties change.
class PLAYERSTATION_DLL DtVreSelectConnectionPageDriver : public QObject
{
   Q_OBJECT;
 
   //! \brief Name of the connection driver
   //!
   //! QML property for the display name of this connection driver.
   //! This is typically used in the UI to identify the driver to the user.
   Q_PROPERTY(QString driverName READ getDriverName WRITE setDriverName NOTIFY driverNameChanged);
 
   //! \brief Type of the connection driver
   //!
   //! QML property for the type of this connection driver (e.g., "DIS" or "HLA").
   //! This identifies the protocol used by this driver.
   Q_PROPERTY(QString driverType READ getDriverType WRITE setDriverType NOTIFY driverTypeChanged);
 
   //! \brief Auto-connect state of the driver
   //!
   //! QML property indicating whether this driver should automatically
   //! connect on application startup.
   Q_PROPERTY(bool autoConnect READ isAutoConnect WRITE setAutoConnect NOTIFY autoConnectChanged);
 
   //! \brief Active connection state
   //!
   //! QML property indicating whether this driver is currently the
   //! active connection for the application.
   Q_PROPERTY(bool activeConnection READ isActiveConnection WRITE setActiveConnection NOTIFY activeConnectionChanged);
 
public:
   //! \brief Constructor
   //! \param parent Optional parent QObject for memory management
   //!
   //! Creates a new connection driver with default property values.
   //! Sets initial state with empty names and false flags.
   explicit DtVreSelectConnectionPageDriver(QObject* parent = nullptr);
 
   //! \brief Destructor
   //!
   //! Cleans up resources used by the connection driver.
   virtual ~DtVreSelectConnectionPageDriver() override;
 
   //! \brief Gets the name of the driver
   //! \return Name of the driver as a QString
   //!
   //! Returns the display name of this connection driver.
   QString getDriverName() const;
 
   //! \brief Gets the type of the driver
   //! \return Type of the driver as a QString
   //!
   //! Returns the type identifier of this connection driver (e.g., "DIS" or "HLA").
   QString getDriverType() const;
 
   //! \brief Checks if the driver should auto-connect
   //! \return True if the driver should auto-connect, false otherwise
   //!
   //! Determines whether this driver should automatically connect
   //! when the application starts up.
   bool isAutoConnect() const;
 
   //! \brief Checks if the driver is the active connection
   //! \return True if the driver is the active connection, false otherwise
   //!
   //! Determines whether this driver is currently the active
   //! connection for the application.
   bool isActiveConnection() const;
 
   //! \brief Sets driver data from a message
   //! \param msg Pointer to the message containing driver data
   //!
   //! Pure virtual method that must be implemented by derived classes to
   //! parse and apply data from a message. This allows different driver types
   //! to handle their specific configuration data differently.
   virtual void setData(makVre::DtVreMessage* msg) = 0;
 
   //! \brief Saves the current driver configuration
   //!
   //! QML-invokable method that saves the current driver configuration.
   //! Each driver type can implement this differently to handle its specific
   //! configuration data. The base implementation does nothing and is
   //! intended to be overridden by derived classes.
   virtual Q_INVOKABLE void save() {}; // Set this as empty so we can invoke this in our set AutoConnect
 
public slots:
   //! \brief Sets the name of the driver
   //! \param name New name for the driver
   //!
   //! Updates the driver name and emits the driverNameChanged signal.
   virtual void setDriverName(const QString& name);
 
   //! \brief Sets the type of the driver
   //! \param type New type for the driver
   //!
   //! Updates the driver type and emits the driverTypeChanged signal.
   virtual void setDriverType(const QString& type);
 
   //! \brief Sets the auto-connect state of the driver
   //! \param autoConnect New auto-connect state
   //!
   //! Updates the auto-connect state, emits the autoConnectChanged signal,
   //! calls save(), and sends an update message to the network thread to
   //! persist the change. If the value hasn't changed, this is a no-op.
   virtual void setAutoConnect(const bool autoConnect);
 
   //! \brief Sets the active connection state of the driver
   //! \param activeConnection New active connection state
   //!
   //! Updates the active connection state, emits the activeConnectionChanged signal,
   //! calls save(), and sends an update message to the network thread to make this
   //! driver the active connection. If the value hasn't changed, this is a no-op.
   virtual void setActiveConnection(const bool activeConnection);
 
signals:
   //! \brief Signal emitted when the driver name changes
   //! \param name New driver name
   //!
   //! Notifies the QML interface that the driver name has changed.
   void driverNameChanged(QString name);
 
   //! \brief Signal emitted when the driver type changes
   //! \param type New driver type
   //!
   //! Notifies the QML interface that the driver type has changed.
   void driverTypeChanged(QString type);
 
   //! \brief Signal emitted when the auto-connect state changes
   //! \param autoConnect New auto-connect state
   //!
   //! Notifies the QML interface that the auto-connect state has changed.
   void autoConnectChanged(bool autoConnect);
 
   //! \brief Signal emitted when the active connection state changes
   //! \param activeConnection New active connection state
   //!
   //! Notifies the QML interface that the active connection state has changed.
   void activeConnectionChanged(bool activeConnection);
 
protected:
   //! \brief Name of the connection driver
   //!
   //! Stores the display name of this connection driver for UI presentation.
   QString myDriverName;
 
   //! \brief Type of the connection driver
   //!
   //! Stores the type of this connection driver (e.g., "DIS" or "HLA").
   QString myDriverType;
 
   //! \brief Auto-connect state flag
   //!
   //! When true, indicates that this driver should automatically connect
   //! when the application starts up.
   bool myAutoConnect;
 
   //! \brief Active connection state flag
   //!
   //! When true, indicates that this driver is currently the active
   //! connection for the application.
   bool myActiveConnection;
};
 
} // namespace makVre