radioPage.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file radioPage.h
//! \ingroup vrfMakRadioQt
//! \brief Radio control page for the VREngage user interface
//!
//! This file defines the DtRadioPage class, which provides a control page
//! for radio communications in the VREngage user interface. It manages radio
//! widgets and handles radio events.
 
#pragma once
 
#include <vrfMakRadioQt/makRadioQt.h>
#include <vrfMakRadioQt/radioStackWidget.h>
 
#include <vrvCore/DtElementData.h>
 
#include <vrvCoreQt/DtPage.h>
 
#include <QtWidgets/QWidget>
 
#include <vlpi/entityIdentifier.h>
 
class QTimer;
class QStandardItemModel;
class QSortFilterProxyModel;
 
namespace makRadio
{
class DtRadioWidget;
}
 
namespace makVrv
{
class DtVrvRadioManager;
class DtRadioEventProcessor;
 
//! \brief Radio control page for the VREngage user interface
//!
//! This class provides a control page for radio communications in the VREngage
//! user interface. It manages radio widgets, processes radio events, and allows
//! users to interact with the radio simulation subsystem through a graphical interface.
class VRVRADIOQT_DLL DtRadioPage : public DtPage
{
   Q_OBJECT
 
public:
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the radio page, including event connections
   //! and radio widgets.
   virtual ~DtRadioPage();
 
   //! \brief Gets the icon for this page
   //! \return Icon to display for this page in the UI
   //!
   //! Returns the icon that represents this page in menus and tabs.
   virtual QIcon icon();
 
   //! \brief Gets the title for this page
   //! \return Title to display for this page in the UI
   //!
   //! Returns the title that identifies this page in menus and tabs.
   virtual QString title();
 
   //! \brief Gets the class name of the page
   //! \return Reference to the class name string
   //!
   //! Returns the unique class name that identifies this page type in the system.
   virtual const std::string& pageClassName() const;
 
   //! \brief Activates the page when it is displayed
   //!
   //! Called when the page is displayed to the user. Initializes radio connections
   //! and starts processing radio events.
   virtual void activate();
 
   //! \brief Deactivates the page when it is hidden
   //!
   //! Called when the page is hidden from the user. Disconnects from radio events
   //! to prevent unnecessary processing while not visible.
   virtual void deactivate();
 
   //! \brief Finds an entity identifier from its marking text
   //! \param markingText The marking text to search for
   //! \return Entity identifier for the matching entity, or invalid identifier if not found
   //!
   //! Searches for an entity with the specified marking text and returns its identifier.
   //! This is used to associate radio communications with specific entities.
   virtual DtEntityIdentifier findEntityIdFromMarkingText(const std::string& markingText);
 
protected:
   //! \brief Allows the page creator to create instances of this class
   //!
   //! This friendship declaration grants the creator class access to the
   //! protected constructor of this class.
   friend class DtRadioPageCreator;
 
   //! \brief Handles activation-specific tasks
   //!
   //! Called by the activate() method to perform implementation-specific
   //! activation tasks.
   virtual void handleActivate();
 
   //! \brief Handles deactivation-specific tasks
   //!
   //! Called by the deactivate() method to perform implementation-specific
   //! deactivation tasks.
   virtual void handleDeactivate();
 
   //! \brief Constructor
   //! \param de The document environment providing access to application resources
   //! \param parent The parent widget (optional)
   //! \param f Window flags (optional)
   //!
   //! Creates a new radio page with the specified document environment and parent.
   //! This constructor is protected to enforce creation through the factory pattern.
   DtRadioPage(DtDe& de, QWidget* parent = 0, Qt::WindowFlags f = 0);
 
   //! \brief Finds and processes existing entities when the page is activated
   //!
   //! Searches for and processes all existing entities in the simulation
   //! when the page is activated, to ensure all relevant entities are included
   //! in the radio communications system.
   virtual void findExistingEntites();
 
   //! \brief Slot called when elements are ready to be processed
   //! \param elements List of element identifiers that are ready for processing
   //!
   //! Processes elements that have been added or modified in the simulation.
   //! Updates the radio system with information about these elements.
   virtual void slot_elementsReadyToProcess(const DtElementData::ElementIdList& elements);
 
   //! \brief Slot called when elements are removed from the simulation
   //! \param elements List of element identifiers that have been removed
   //!
   //! Handles cleanup and updates the radio system when elements are removed
   //! from the simulation.
   virtual void slot_elementsRemoved(const DtElementData::ElementIdList& elements);
 
   //! \brief Sets up the contents of the widget onto the supplied parent
   //! \param p The parent widget to set up the UI on
   //!
   //! Initializes the UI components of the radio page and adds them to the
   //! specified parent widget.
   void setupUi(QWidget* p);
 
   //! \brief The class name of this page
   //!
   //! Stores the class name string that uniquely identifies this page type.
   std::string myClassName;
 
   //! \brief The radio stack widget containing the radio controls
   //!
   //! Contains the actual radio UI components displayed on this page.
   DtRadioStackWidget* myRadioStack;
 
   //! \brief The radio manager handling radio functionality
   //!
   //! Manages the underlying radio simulation functionality.
   DtVrvRadioManager* myManager;
 
   //! \brief The event processor for radio events
   //!
   //! Processes radio events from the simulation and updates the UI accordingly.
   DtRadioEventProcessor* myEventHandler;
};
 
 
//! \brief Creator class for radio pages
//!
//! This class is responsible for creating instances of the DtRadioPage class.
//! It implements the factory pattern to create and initialize radio pages.
class VRVRADIOQT_DLL DtRadioPageCreator : public DtPageCreator
{
public:
   //! \brief Constructor
   //! \param de The document environment providing access to application resources
   //!
   //! Creates a new radio page creator with the specified document environment.
   DtRadioPageCreator(DtDe& de);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the radio page creator.
   virtual ~DtRadioPageCreator();
 
   //! \brief Gets the name of the page class this creator creates
   //! \return The unique class name string for the created page type
   //!
   //! Returns the unique class name that identifies the type of page this creator
   //! produces. This is NOT the title of the page. When replacing a page in the
   //! application, the pageClassName should remain the same to ensure proper
   //! page replacement behavior.
   virtual std::string pageClassName() const;
 
   //! \brief Creates a new radio page instance
   //! \param parent The parent widget (optional)
   //! \param f Window flags (optional)
   //! \return Pointer to the newly created page
   //!
   //! Creates and initializes a new instance of DtRadioPage with the specified
   //! parent widget and window flags.
   virtual DtPage* create(QWidget* parent = 0, Qt::WindowFlags f = 0);
};
} // namespace makVrv