vreSelectConnectionPage.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreSelectConnectionPage.h
//! \brief Defines the connection selection page for VR-Engage
//!
//! This file contains the DtVreSelectConnectionPage class which provides the UI
//! for configuring and selecting network connections (DIS or HLA) for the
//! VR-Engage application. It allows users to choose between different network
//! protocols and configure their connection parameters.
 
#pragma once
 
#include <vrePlayerStation/export.h>
#include "vrePlayerStation/vreHeaderFooterUIBase.h"
 
#include <QObject>
 
#include "vreMessageManager/vreMessage.h"
 
class QQuickItem;
class QStringList;
 
namespace makVrv
{
class DtVrlinkDriver;
}
 
namespace makVre
{
//! \brief Forward declaration of the player station application class
class DtPlayerStationApp;
 
//! \brief Forward declaration of the connection page driver base class
class DtVreSelectConnectionPageDriver;
 
//! \brief Forward declaration of the DIS-specific connection driver class
class DtVreSelectConnectionPageDriverDIS;
 
//! \brief Forward declaration of the HLA-specific connection driver class
class DtVreSelectConnectionPageDriverHLA;
 
//! \brief UI page for selecting and configuring network connections
//!
//! DtVreSelectConnectionPage provides a user interface for selecting and configuring
//! network connections in VR-Engage. It displays available connection protocols
//! (DIS and HLA) and allows users to configure connection parameters. This page
//! is typically shown during the initial setup phase or when changing connection
//! settings.
class PLAYERSTATION_DLL DtVreSelectConnectionPage : public DtVreHeaderFooterUIBase
{
   Q_OBJECT;
 
public:
   //! \brief Constructor
   //! \param app Reference to the player station application
   //! \param target_window Name of the window to display in (empty for default)
   //!
   //! Creates a new connection selection page UI for the specified application
   //! and target window. Initializes network message handlers and connections.
   DtVreSelectConnectionPage(DtPlayerStationApp& app, const std::string& target_window = "");
 
   //! \brief Destructor
   //!
   //! Cleans up resources, disconnects signals, and unregisters message handlers.
   virtual ~DtVreSelectConnectionPage() override;
 
   //! \brief Initializes the main content of the page
   //!
   //! Sets up the main content area of the page, including the page title
   //! and application mode properties. Called during initialization.
   virtual void initMain() override;
 
   //! \brief Updates the page each frame
   //! \param dt Time in seconds since the last update
   //!
   //! Called once per frame to update any time-dependent elements on the page.
   virtual void tick(double dt) override;
   //! \brief Handles connection button clicks
   //!
   //! Called when the connection button is clicked. Sends a back button
   //! clicked message to the system to handle the navigation.
   virtual void slot_connectionClicked() override;
 
   //! \brief Handles network disconnection messages
   //! \param msg Pointer to the network disconnected message
   //! \return Message handling result
   //!
   //! Processes messages indicating that the network connection has been
   //! disconnected and updates the UI state accordingly.
   virtual DtVreMessageResult handleNetworkDisconnected(DtVreMessage* msg);
 
   //! \brief Handles network connection messages
   //! \param msg Pointer to the network connected message
   //! \return Message handling result
   //!
   //! Processes messages indicating that a network connection has been
   //! established and updates the UI state accordingly.
   virtual DtVreMessageResult handleNetworkConnected(DtVreMessage* msg);
 
   //! \brief Sets the visibility of the page
   //! \param visible True to show the page, false to hide it
   //!
   //! Controls whether the connection selection page is visible. When made
   //! visible, this method updates the page title and application mode.
   virtual void setVisibility(bool visible) override;
 
   //! \brief Initializes the footer area of the page
   //!
   //! Sets up the footer area of the page, including configuring the back button
   //! based on the current application state. Called during initialization.
   virtual void initFooter() override;
 
   //! \brief Handles application mode changes
   //! \param newAppMode Identifier of the new application mode
   //! \param oldAppMode Identifier of the previous application mode
   //!
   //! Updates the page when the application mode changes, ensuring the UI
   //! reflects the current mode appropriately.
   virtual void appModeUpdated(const std::string& newAppMode, const std::string& oldAppMode) override;
 
protected:
   //! \brief Slot called when drivers are about to auto-start
   //!
   //! Called when the display engine signals that drivers are about to be
   //! automatically started. This triggers requests for connection information
   //! from the network thread to update the available connections.
   void slot_aboutToAutoStartDrivers();
 
protected:
   //! \brief Flag indicating network connection status
   //!
   //! True when the network is connected, false when disconnected.
   //! Used to control UI elements based on connectivity state.
   bool myIsNetworkConnected;
};
 
//! \brief QML interface for the connection selection page
//!
//! DtVreSelectConnectionPageQML provides the interface between the C++ backend
//! and the QML frontend of the connection selection page. It manages the list
//! of available connection drivers and handles communication between the UI
//! and the underlying connection system.
class PLAYERSTATION_DLL DtVreSelectConnectionPageQML : public QObject
{
   Q_OBJECT;
 
   //! \brief List of available connection drivers
   //!
   //! QML property that exposes the list of available connection drivers
   //! to the QML frontend. Can be accessed and modified from QML.
   Q_PROPERTY(QVariantList drivers READ getDrivers WRITE setDrivers NOTIFY driversChanged);
 
public:
   //! \brief Constructor
   //! \param parent Optional parent QObject for memory management
   //!
   //! Creates a new QML interface for the connection selection page.
   //! Registers message handlers and requests connection information.
   explicit DtVreSelectConnectionPageQML(QObject* parent = nullptr);
 
   //! \brief Destructor
   //!
   //! Cleans up resources and unregisters message handlers.
   virtual ~DtVreSelectConnectionPageQML() override;
 
   //! \brief Gets the list of available connection drivers
   //! \return List of connection drivers as QVariantList
   //!
   //! Returns the current list of available connection drivers (DIS, HLA)
   //! for display in the QML interface. Each driver contains information
   //! about the connection protocol and its configuration options.
   virtual QVariantList getDrivers();
 
   //! \brief Invokable method to navigate back
   //!
   //! QML-invokable method that handles back navigation requests from the UI.
   //! This is typically connected to back buttons in the QML interface.
   virtual Q_INVOKABLE void back();
 
protected:
   //! \brief Handles HLA connection information messages
   //! \param msg Pointer to the HLA connection info message
   //! \return Message handling result
   //!
   //! Processes messages containing information about available HLA
   //! connections and updates the driver list accordingly.
   virtual DtVreMessageResult handleHLADriverMessage(DtVreMessage* msg);
 
   //! \brief Handles DIS connection information messages
   //! \param msg Pointer to the DIS connection info message
   //! \return Message handling result
   //!
   //! Processes messages containing information about available DIS
   //! connections and updates the driver list accordingly.
   virtual DtVreMessageResult handleDISDriverMessage(DtVreMessage* msg);
 
public slots:
   //! \brief Sets the list of connection drivers
   //! \param list New list of connection drivers
   //!
   //! Updates the internal list of connection drivers and notifies
   //! the QML interface of the change.
   void setDrivers(QVariantList list);
 
   //! \brief Adds a connection driver to the list
   //! \param driver Pointer to the driver to add
   //!
   //! Adds a new connection driver to the list of available drivers
   //! and updates the QML interface.
   void addDriver(DtVreSelectConnectionPageDriver* driver);
 
signals:
   //! \brief Signal emitted when the driver list changes
   //! \param list Updated list of drivers
   //!
   //! Notifies the QML interface that the list of available
   //! connection drivers has changed.
   void driversChanged(QVariantList list);
 
   //! \brief Signal emitted when all drivers have finished loading
   //!
   //! Notifies the QML interface that all connection drivers have
   //! finished loading and the UI can be updated accordingly.
   void driversDoneLoading();
 
protected:
   //! \brief List of available connection drivers
   //!
   //! Stores the current list of available connection drivers that
   //! can be selected and configured by the user.
   QList<DtVreSelectConnectionPageDriver*> myDrivers;
 
   //! \brief Pointer to the player station application
   //!
   //! Provides access to application services and state. Not owned
   //! by this class, simply a convenience pointer.
   DtPlayerStationApp* myApp;
};
 
} // namespace makVre