vreChatWindowModel.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file vreChatWindowModel.h
//! \brief Defines the data model for the chat window in VR-Engage
//!
//! This file contains the data model classes used by the chat window system,
//! including DtChatEntry for individual chat messages and DtVreChatModel
//! for the collection of messages displayed in the chat UI.
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include <QObject>
 
namespace makVre
{
//! \brief Represents a single chat message entry
//!
//! DtChatEntry encapsulates a single chat message in the chat system,
//! including the sender's username, force affiliation, target channel,
//! message content, and display properties such as opacity and visibility.
//! Each entry corresponds to one message bubble in the chat UI.
class PLAYERSTATION_DLL DtChatEntry
{
public:
   //! \brief Constructor
   //! \param username Name of the user who sent the message
   //! \param force Force identifier of the sender (friendly=1, enemy=2, etc.)
   //! \param channel Target channel for the message
   //! \param message Content of the chat message
   //!
   //! Creates a new chat entry with the specified sender information and message content.
   DtChatEntry(const std::string& username, int force, const std::string& channel, const std::string& message);
 
   //! \brief Default destructor
   ~DtChatEntry() = default;
 
   //! \brief Gets the username of the message sender
   //! \return Username as a QString
   QString username() const;
 
   //! \brief Sets the username of the message sender
   //! \param val New username
   void setUsername(QString val);
 
   //! \brief Gets the channel the message was sent to
   //! \return Channel name as a QString
   QString channel() const;
 
   //! \brief Sets the channel for the message
   //! \param val New channel name
   void setChannel(QString val);
 
   //! \brief Gets the force identifier of the sender
   //! \return Force identifier (friendly=1, enemy=2, etc.)
   int force() const;
 
   //! \brief Sets the force identifier of the sender
   //! \param val New force identifier
   void setForce(int val);
 
   //! \brief Gets the content of the message
   //! \return Message text as a QString
   QString message() const;
 
   //! \brief Sets the content of the message
   //! \param val New message text
   void setMessage(QString val);
 
   //! \brief Gets the opacity of the message in the UI
   //! \return Opacity value (0.0 to 1.0)
   double opacity() const;
 
   //! \brief Sets the opacity of the message in the UI
   //! \param val New opacity value
   void setOpacity(double val);
 
   //! \brief Checks if the message fade timer has started
   //! \return True if timer has started, false otherwise
   bool timerStarted() const;
 
   //! \brief Sets the timer started flag for message fading
   //! \param val New timer started state
   void setTimerStarted(bool val);
 
   //! \brief Checks if the message is visible in the UI
   //! \return True if visible, false if hidden
   bool visible() const;
 
   //! \brief Sets the visibility of the message in the UI
   //! \param val New visibility state
   void setVisible(bool val);
 
protected:
   //! \brief Username of the message sender
   QString myUsername;
 
   //! \brief Channel the message was sent to
   QString myChannel;
 
   //! \brief Force identifier of the sender (friendly=1, enemy=2, etc.)
   int myForce;
 
   //! \brief Content of the chat message
   QString myMessage;
 
   //! \brief Opacity of the message in the UI (0.0 to 1.0)
   double myOpacity;
 
   //! \brief Flag indicating if the fade timer has started
   bool myTimerStarted;
 
   //! \brief Flag indicating if the message is visible in the UI
   bool myVisible;
};
 
//! \brief Data model for the chat window contents
//!
//! DtVreChatModel is a list model that maintains the collection of chat messages
//! displayed in the chat UI. It extends QAbstractListModel to provide a Qt-compatible
//! interface for the QML-based chat window, exposing properties of DtChatEntry
//! objects as roles that can be bound to UI elements.
class PLAYERSTATION_DLL DtVreChatModel : public QAbstractListModel
{
   Q_OBJECT;
 
public:
   //! \brief Enumeration of data roles for accessing chat entry properties
   //!
   //! Defines the roles used to access specific properties of chat entries
   //! in the QML view. These roles are used in QML bindings to display the
   //! appropriate data for each chat message.
   enum ChatRoles
   {
      UsernameRole = Qt::UserRole + 1, //!< Role for accessing the sender's username
      ChannelRole,                     //!< Role for accessing the message channel
      ForceRole,                       //!< Role for accessing the sender's force identifier
      MessageRole,                     //!< Role for accessing the message content
      OpacityRole,                     //!< Role for accessing the message opacity
      TimerStartedRole,                //!< Role for accessing the timer started flag
      VisibleRole                      //!< Role for accessing the message visibility
   };
 
public:
   //! \brief Constructor
   //! \param parent Parent QObject (default: nullptr)
   //!
   //! Creates a new chat model with the specified parent object.
   DtVreChatModel(QObject* parent = nullptr);
 
   //! \brief Default destructor
   virtual ~DtVreChatModel() override = default;
 
   //! \brief Clears all messages from the model
   //!
   //! Removes all chat entries from the model, effectively clearing
   //! the chat window display.
   virtual void clear();
 
   //! \brief Adds a new chat message to the model
   //! \param entry Chat entry to add
   //!
   //! Adds a new chat message to the model, which will then appear
   //! in the chat window UI.
   virtual void addChat(const DtChatEntry& entry);
 
   //! \brief Sorts the model contents
   //! \param column Column to sort by
   //! \param order Sort order (ascending or descending)
   //!
   //! Required implementation from QAbstractListModel. Sorts the chat
   //! entries according to the specified criteria.
   virtual void sort(int column, Qt::SortOrder order = Qt::AscendingOrder) override;
 
   //! \brief Removes rows from the model
   //! \param row Starting row to remove
   //! \param column Column (unused in list models)
   //! \param parent Parent index (unused in list models)
   //! \return True if rows were successfully removed
   //!
   //! Removes the specified chat entries from the model.
   virtual bool removeRows(int row, int column = 0, const QModelIndex& parent = QModelIndex()) override;
 
   //! \brief Gets the number of chat entries in the model
   //! \param parent Parent index (unused in list models)
   //! \return Number of chat entries
   //!
   //! Returns the total number of chat messages in the model.
   virtual int rowCount(const QModelIndex& parent = QModelIndex()) const override;
 
   //! \brief Gets data for a specific role and index
   //! \param index Model index to get data for
   //! \param role Data role to retrieve
   //! \return QVariant containing the requested data
   //!
   //! Retrieves specific property data from a chat entry based on the
   //! specified role. This is used by the QML view to display chat messages.
   virtual QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
 
   //! \brief Sets data for a specific role and index
   //! \param index Model index to set data for
   //! \param value New value to set
   //! \param role Data role to set
   //! \return True if data was successfully set
   //!
   //! Updates a specific property of a chat entry based on the
   //! specified role and value.
   virtual bool setData(const QModelIndex& index, const QVariant& value, int role) override;
 
protected:
   //! \brief Maps role enum values to role name strings
   //! \return Hash mapping role IDs to role names
   //!
   //! Provides the mapping between role enum values and their string names,
   //! which is required for QML access to the model data.
   virtual QHash<int, QByteArray> roleNames() const override;
 
protected:
   //! \brief List of chat entries in the model
   //!
   //! Contains all the chat messages currently displayed in the chat window.
   QList<DtChatEntry> myChat;
};
} // namespace makVre