vreAppPage.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file vreAppPage.h
//! \brief Defines the main application UI page for VR-Engage
//!
//! This file contains the DtVreAppPage class which implements the main application
//! page for VR-Engage. It provides the UI elements and functionality for the in-game
//! screen, including access to session management, role selection, and application
//! control. This page is displayed when a user is engaged with a role in the simulation.
 
#pragma once
 
#include "vrePlayerStation/export.h"
#include "vrePlayerStation/vreHeaderFooterUIBase.h"
 
#include <QObject>
 
class QQuickItem;
 
namespace makVre
{
class DtPlayerStationApp;
 
//! \brief Structure containing state values for the application page
//!
//! DtVreAppPageValues stores the current state information displayed in the
//! application page. This includes engagement status, session information,
//! and currently loaded terrain and scenario data.
struct DtVreAppPageValues
{
   //! \brief Current application state name
   std::string myCurrentState;
 
   //! \brief Whether the user is currently engaged with a role
   bool myIsEngaged;
 
   //! \brief Whether the user is currently in a session
   bool myInSession;
 
   //! \brief Whether the simulation is currently running
   bool myIsRunning;
 
   //! \brief Currently loaded scenario name
   std::string myScenario;
 
   //! \brief Currently loaded terrain name
   std::string myTerrain;
};
 
//! \brief Main application page for the VR-Engage in-game interface
//!
//! DtVreAppPage implements the main application page displayed when a user
//! is engaged with a role in VR-Engage. It provides access to session management,
//! role selection, and application control through a QML-based user interface.
//! The page includes information about the current entity, role, session, and
//! scenario, and provides buttons for navigation to other parts of the application.
class PLAYERSTATION_DLL DtVreAppPage : public DtVreHeaderFooterUIBase
{
   Q_OBJECT
 
public:
   //! \brief Constructor
   //! \param app Reference to the player station application
   //! \param target_window Target window name for this page (empty for default)
   //!
   //! Creates a new application page instance associated with the specified
   //! player station application. The optional target_window parameter allows
   //! specifying which window should display this page.
   DtVreAppPage(DtPlayerStationApp& app, const std::string& target_window = "");
 
   //! \brief Destructor
   //!
   //! Cleans up resources used by the application page.
   virtual ~DtVreAppPage() override;
 
   //! \brief Updates the page state
   //! \param dt Time elapsed since the last update in seconds
   //!
   //! Called once per frame to update the page state. This method can be used
   //! to handle animations, timers, or other time-dependent functionality.
   virtual void tick(double dt) override;
 
   //! \brief Initializes the main QML content
   //!
   //! Sets up the main QML content for the page, including connecting signals
   //! and slots between C++ and QML. This is called during page initialization
   //! after the QML has been loaded.
   virtual void initMain() override;
 
   //! \brief Sets the visibility of the page
   //! \param visible True to show the page, false to hide it
   //!
   //! Overrides the base class implementation to update page information
   //! when the page becomes visible. This ensures that the displayed information
   //! is current whenever the page is shown.
   virtual void setVisibility(bool visible) override;
 
   //! \brief Sets the enabled state of the Choose Role button
   //! \param enable True to enable the button, false to disable it
   //!
   //! Controls whether the Choose Role button is interactive. The button is
   //! typically disabled in lockdown mode or when there is no network connection.
   virtual void setChooseRoleBtnState(bool enable);
 
   //! \brief Sets the enabled state of the Return button
   //! \param enable True to enable the button, false to disable it
   //!
   //! Controls whether the Return button is interactive. The button is
   //! typically disabled when the user is not engaged with a role.
   virtual void setReturnBtnState(bool enable);
 
   //! \brief Sets the enabled state of the Choose Session button and dialog
   //! \param enableBtn True to enable the button, false to disable it
   //! \param enableDialog True to show a confirmation dialog, false for direct action
   //!
   //! Controls whether the Choose Session button is interactive and whether
   //! it should show a confirmation dialog when clicked. The dialog is typically
   //! enabled when the user is already in a session.
   virtual void setChooseSessionBtnState(bool enableBtn, bool enableDialog);
 
   //! \brief Updates the displayed terrain information
   //! \param terrain Name of the current terrain
   //!
   //! Sets the terrain name displayed in the UI. This shows the currently
   //! loaded terrain database used by the simulation.
   virtual void setTerrain(const std::string& terrain);
 
   //! \brief Updates the displayed scenario information
   //! \param scenario Name of the current scenario
   //!
   //! Sets the scenario name displayed in the UI. This shows the currently
   //! loaded scenario file used by the simulation.
   virtual void setScenario(const std::string& scenario);
 
   //! \brief Updates the displayed session type information
   //! \param type Type of the current session
   //!
   //! Sets the session type displayed in the UI (e.g., "Unhosted",
   //! "Self-hosted", or "Externally Hosted").
   virtual void setSessionType(const QString& type);
 
   //! \brief Refreshes all menu information
   //!
   //! Updates all displayed information in the UI, including entity details,
   //! role information, scenario data, and session state. Called when the
   //! page becomes visible or when information changes.
   virtual void refreshMenus();
 
public slots:
   //! \brief Slot called when the Return button is clicked
   //!
   //! Handles the Return button click event. This sends a UIBackButtonClickedMessage
   //! to the message system to request returning to the previous screen.
   virtual void slot_returnClicked();
 
   //! \brief Slot called when the Choose Role button is clicked
   //!
   //! Handles the Choose Role button click event. This sends a UIChooseRoleButtonClickedMessage
   //! to the message system to request displaying the Choose Role interface.
   virtual void slot_chooseRoleClicked();
 
   //! \brief Slot called when the Choose Session button is clicked
   //!
   //! Handles the Choose Session button click event. This displays the Choose Session
   //! dialog to allow selecting a different simulation session.
   virtual void slot_chooseSessionClicked();
 
   //! \brief Slot called when the Choose Session dialog is opened
   //!
   //! Handles the Choose Session dialog open event. This is used to set up
   //! the dialog and connect signals for its interactions.
   virtual void slot_chooseSessionOpened();
 
   //! \brief Slot called when the Choose Session dialog is closed
   //!
   //! Handles the Choose Session dialog close event. This is used to clean up
   //! any temporary resources and disconnect signals.
   virtual void slot_chooseSessionClosed();
 
   //! \brief Slot called when the Choose Session dialog is accepted
   //!
   //! Handles the Choose Session dialog accept event (e.g., OK button clicked).
   //! This closes the dialog and sends a UIChooseSessionButtonClickedMessage to
   //! the message system to request changing to the selected session.
   virtual void slot_chooseSessionAccepted();
 
   //! \brief Slot called when the Choose Session dialog is rejected
   //!
   //! Handles the Choose Session dialog reject event (e.g., Cancel button clicked).
   //! This closes the dialog without making any changes to the session.
   virtual void slot_chooseSessionRejected();
 
   //! \brief Slot called when the Exit dialog is opened
   //!
   //! Handles the Exit dialog open event. This checks application settings to
   //! determine whether to show the dialog or exit immediately, and connects
   //! signals for dialog interactions.
   virtual void slot_appMenuExitOpened();
 
   //! \brief Slot called when the Exit dialog is accepted
   //!
   //! Handles the Exit dialog accept event (e.g., OK button clicked).
   //! This updates application settings and exits the application.
   virtual void slot_appMenuExitAccepted();
 
   //! \brief Slot called when the Exit dialog is rejected
   //!
   //! Handles the Exit dialog reject event (e.g., Cancel button clicked).
   //! This closes the dialog without exiting the application.
   virtual void slot_appMenuExitRejected();
 
   //! \brief Slot called when the Exit dialog is closed
   //!
   //! Handles the Exit dialog close event. This is used to clean up
   //! any temporary resources and disconnect signals.
   virtual void slot_appMenuExitClosed();
 
protected:
   //! \brief Updates the UI when the running state changes
   //! \param runState New running state of the simulation
   //!
   //! Overrides the base class implementation to update the status panel
   //! when the simulation running state changes. This ensures that the UI
   //! reflects the current state of the simulation (running or paused).
   virtual void runningStateUpdated(bool runState) override;
};
} // namespace makVre