vreChooseRolePage.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreChooseRolePage.h
//! \brief Defines UI components for selecting observer views (roles) in VR-Engage
//!
//! This file contains classes that implement the role selection screen in VR-Engage,
//! allowing users to select different observer views, such as driver, gunner, or commander.
//! It includes models for representing observer views and a UI controller for managing
//! the selection screen.
 
#pragma once
 
#include "vrePlayerStation/export.h"
#include "vrePlayerStation/vreHeaderFooterUIBase.h"
#include "vreQtQuickRenderer/DtQtQuickRenderer.h"
 
#include <QObject>
#include <QAbstractListModel>
 
//! Forward declaration of Qt Quick Item class
class QQuickItem;
 
namespace makArchives
{
//! Forward declaration of observer state records list
class DtObserverStateRecordsList;
 
//! Forward declaration of observer state record
class DtObserverStateRecord;
} // namespace makArchives
 
namespace makVre
{
//! Forward declaration of the player station application
class DtPlayerStationApp;
 
//! \brief Data structure representing an observer view entry
//!
//! This class stores information about an observer view, including its name,
//! whether it uses 2D projection, and whether it's the default view.
class PLAYERSTATION_DLL DtObserverViewEntry
{
public:
   //! \brief Default constructor
   //!
   //! Creates an empty observer view entry.
   DtObserverViewEntry();
 
   //! \brief Parameterized constructor
   //! \param observerName The name of the observer view
   //! \param projection2D Flag indicating if the view uses 2D projection
   //! \param defaultView Flag indicating if this is the default view
   //!
   //! Creates an observer view entry with the specified parameters.
   DtObserverViewEntry(const QString& observerName, const bool projection2D, const bool defaultView);
 
   //! \brief Gets the observer view name
   //! \return The name of the observer view
   QString getObserverName() const;
 
   //! \brief Sets the observer view name
   //! \param name The new name to set
   void setObserverName(const QString& name);
 
   //! \brief Checks if the view uses 2D projection
   //! \return True if the view uses 2D projection, false otherwise
   bool getProjectionIs2D() const;
 
   //! \brief Sets whether the view uses 2D projection
   //! \param is2D True if the view should use 2D projection, false otherwise
   void setProjectionIs2D(const bool is2D);
 
   //! \brief Checks if this is the default view
   //! \return True if this is the default view, false otherwise
   bool getDefaultView() const;
 
   //! \brief Sets whether this is the default view
   //! \param isDefaultView True if this should be the default view, false otherwise
   void setDefaultView(const bool isDefaultView);
 
protected:
   //! \brief The name of the observer view
   QString myObserverName;
 
   //! \brief Flag indicating if the view uses 2D projection
   bool myProjectionIs2D;
 
   //! \brief Flag indicating if this is the default view
   bool myDefaultView;
};
 
//! \brief Model class for observer views to be used with QML views
//!
//! This class implements a Qt list model for observer view entries that can be
//! bound to QML list views. It provides methods for adding, removing, and accessing
//! observer view entries, as well as the required Qt model/view API implementation.
class PLAYERSTATION_DLL DtObserverViewsQmlModel : public QAbstractListModel
{
   Q_OBJECT;
 
public:
   //! \brief Enum defining custom roles for the model data
   enum ObserverViewsRoles
   {
      ObserverNameRole = Qt::UserRole + 1, //!< Role for accessing the observer name
      ProjectionRole,                      //!< Role for accessing the projection type
      DefaultViewRole                      //!< Role for accessing the default view flag
   };
 
   //! \brief Constructor
   //! \param parent The parent QObject (optional)
   //!
   //! Creates an empty observer views model.
   DtObserverViewsQmlModel(QObject* parent = 0);
 
   //! \brief Adds an observer view to the model
   //! \param entry The observer view entry to add
   virtual void addObserverView(const DtObserverViewEntry& entry);
 
   //! \brief Clears all observer views from the model
   virtual void clear();
 
   //! \brief Finds the index of an observer view by name
   //! \param observerName The name of the observer view to find
   //! \return The index of the observer view, or -1 if not found
   virtual int getIndexOfName(const QString& observerName);
 
   //! \brief Gets the observer name at the specified index
   //! \param idx The index to get the observer name for
   //! \return The observer name at the specified index
   virtual QString getObserverName(const int idx);
 
   //! \brief Sorts the model data
   //! \param column The column to sort by
   //! \param order The sort order
   //! \note Must be implemented in subclasses
   virtual void sort(int column, Qt::SortOrder order = Qt::AscendingOrder) override;
 
   //! \brief Removes rows from the model
   //! \param row The starting row to remove
   //! \param column The column (unused, defaults to 0)
   //! \param parent The parent index (unused for list models)
   //! \return True if rows were successfully removed, false otherwise
   virtual bool removeRows(int row, int column = 0, const QModelIndex& parent = QModelIndex()) override;
 
   //! \brief Gets the number of rows in the model
   //! \param parent The parent index (unused for list models)
   //! \return The number of observer views in the model
   virtual int rowCount(const QModelIndex& parent = QModelIndex()) const override;
 
   //! \brief Gets data for a specific index and role
   //! \param index The model index to get data for
   //! \param role The role to get data for
   //! \return The requested data as a QVariant
   virtual QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
 
   //! \brief Sets data for a specific index and role
   //! \param index The model index to set data for
   //! \param value The value to set
   //! \param role The role to set data for
   //! \return True if data was successfully set, false otherwise
   virtual bool setData(const QModelIndex& index, const QVariant& value, int role) override;
 
protected:
   //! \brief Gets the role names mapping for QML integration
   //! \return A hash mapping role IDs to role names
   virtual QHash<int, QByteArray> roleNames() const override;
 
   //! \brief The list of observer view entries in the model
   QList<DtObserverViewEntry> myObserverViews;
};
 
 
//! \brief UI controller for the role selection screen
//!
//! This class manages the UI for selecting observer views (roles) in VR-Engage.
//! It displays a list of available roles, handles user selection, and provides
//! mechanisms for filtering and navigating the available views.
class PLAYERSTATION_DLL DtVreChooseRolePage : public DtVreHeaderFooterUIBase
{
   Q_OBJECT
 
public:
   //! \brief Constructor
   //! \param app Reference to the player station application
   //! \param target_window The target window name (optional)
   //!
   //! Creates a new choose role page for the specified application and window.
   DtVreChooseRolePage(DtPlayerStationApp& app, const std::string& target_window = "");
 
   //! \brief Destructor
   //!
   //! Cleans up resources used by the choose role page.
   virtual ~DtVreChooseRolePage() override;
 
   //! \brief Updates the page state
   //! \param dt The time elapsed since the last update in seconds
   //!
   //! Performs periodic updates of the page state and components.
   virtual void tick(double dt) override;
 
   //! \brief Initializes the main UI components
   //!
   //! Sets up the initial state of the page and its components.
   virtual void initMain() override;
 
   //! \brief Sets the visibility of the role selection background
   //! \param visible True to show the background, false to hide it
   virtual void setChooseRoleBackgroundVisibility(bool visible);
 
   //! \brief Sets the visibility of the observer views list
   //! \param visible True to show the observer views, false to hide them
   virtual void setObserverViewsVisibility(bool visible);
 
   //! \brief Sets the visibility of the lockdown mode indicator
   //! \param visible True to show the indicator, false to hide it
   //! \param overrideLockdown If true, shows the indicator even if not in lockdown mode
   virtual void setLockdownModeIndicatorVisibility(bool visible, bool overrideLockdown = false);
 
   //! \brief Sets the text of the lockdown mode indicator
   //! \param text The text to display in the lockdown mode indicator
   virtual void setLockdownModeIndicatorText(const QString& text);
 
   //! \brief Handles a click on an observer view
   //! \param observerName The name of the observer view that was clicked
   //! \param animated Whether to animate the transition (default: false)
   //!
   //! This method is invokable from QML and handles selection of an observer view.
   Q_INVOKABLE virtual void observerViewClicked(QString observerName, bool animated = false);
 
   //! \brief Sets the visibility of the page
   //! \param visible True to show the page, false to hide it
   //! \override Override of the base class method with additional functionality
   virtual void setVisibility(bool visible) override;
 
   //! \brief Handles application mode changes
   //! \param newAppMode The new application mode
   //! \param oldAppMode The previous application mode
   //! \override Override of the base class method to update UI based on app mode
   virtual void appModeUpdated(const std::string& newAppMode, const std::string& oldAppMode) override;
 
public slots:
   //! \brief Handles the exit dialog being opened
   //! \override Override of the base class method
   virtual void slot_exitOpened() override;
 
   //! \brief Handles the exit dialog being closed
   //! \override Override of the base class method
   virtual void slot_exitClosed() override;
 
   //! \brief Handles the help dialog being opened
   //! \override Override of the base class method
   virtual void slot_helpOpened() override;
 
   //! \brief Handles the help dialog being closed
   //! \override Override of the base class method
   virtual void slot_helpClosed() override;
 
   //! \brief Handles the settings dialog being opened
   //! \override Override of the base class method
   virtual void slot_settingsOpened() override;
 
   //! \brief Handles the settings dialog being closed
   //! \override Override of the base class method
   virtual void slot_settingsClosed() override;
 
   //! \brief Handles the connection button being clicked
   //! \override Override of the base class method
   virtual void slot_connectionClicked() override;
 
protected:
   //! \brief Handles back button clicks
   //! \param msg The message containing back button click information
   //! \return Message handling result (HANDLED or IGNORED)
   DtVreMessageResult handleBackButtonClicked(DtVreMessage* msg);
 
   //! \brief Handles changes to the observer views list
   //! \param observerViewList The updated list of observer views
   virtual void slot_observerViewsChanged(const makArchives::DtObserverStateRecordsList& observerViewList);
 
   //! \brief Handles clearing of all observer views
   virtual void slot_observerViewsCleared();
 
   //! \brief Handles addition of a new observer view
   //! \param observerView The observer view that was added
   virtual void slot_observerViewAdded(const makArchives::DtObserverStateRecord& observerView);
 
   //! \brief Handles removal of an observer view
   //! \param observerView The observer view that was removed
   virtual void slot_observerViewRemoved(const makArchives::DtObserverStateRecord& observerView);
 
   //! \brief Handles renaming of an observer view
   //! \param oldName The previous name of the observer view
   //! \param observerView The observer view with its new name
   virtual void slot_observerViewRenamed(
      const std::string& oldName, const makArchives::DtObserverStateRecord& observerView);
 
protected:
   //! \brief Model containing the observer views to display
   DtObserverViewsQmlModel myObserverViewsModel;
 
   //! \brief Reference to the manager of observer views
   makVrv::DtObserverViewsManager& myObserverViewsManager;
};
} // namespace makVre