vreEventProcessor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreEventProcessor.h
//! \brief Defines the event processor for handling display channel events
//!
//! This file contains the DtVreEventProcessor class which provides functionality
//! for redirecting events between display channels. It allows events targeted at
//! one channel to be processed by another, which is useful for creating coordinated
//! multi-channel displays or for managing event handling in complex visualization setups.
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include "vreMessageManager/vreMessage.h"
 
#include <vrvCore/DtEventProcessorInterface.h>
 
namespace makVrv
{
//! \brief Forward declaration of the display channel class
class DtChannel;
 
//! \brief Forward declaration of the channel manager class
class DtChannelManager;
}; // namespace makVrv
 
namespace makVre
{
//! \brief Forward declaration of the initialization table class
class DtInitTable;
 
//! \brief Forward declaration of the player station class
class DtPlayerStation;
 
//! \brief Event processor for handling and redirecting display channel events
//!
//! DtVreEventProcessor extends the base event processor interface to provide
//! the ability to redirect events from one display channel to another. This is
//! useful in scenarios where multiple channels need coordinated behavior or
//! when events need to be processed by a different channel than the one they
//! were originally targeted for. The processor maintains a mapping of channel
//! associations and routes events accordingly.
class PLAYERSTATION_DLL DtVreEventProcessor : public makVrv::DtEventProcessorInterface
{
public:
   //! \brief Constructor
   //! \param de Reference to the display engine
   //!
   //! Creates a new event processor associated with the given display engine.
   DtVreEventProcessor(makVrv::DtDe& de);
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of the event processor resources.
   virtual ~DtVreEventProcessor() override;
 
   //! \brief Initializes the event processor
   //! \return True if initialization succeeded, false otherwise
   //!
   //! Sets up the event processor, including registering message handlers
   //! and connecting to signals for channel management.
   virtual bool init();
 
   //! \brief Shuts down the event processor
   //!
   //! Cleans up resources and disconnects from signals and message handlers.
   //! This should be called when the event processor is no longer needed.
   virtual void shutdown();
 
   //! \brief Gets the target channel for a given source channel
   //! \param source Pointer to the source channel
   //! \return Pointer to the target channel, or the source channel if no association exists
   //!
   //! Looks up the target channel associated with the given source channel.
   //! If no association exists, returns the source channel unchanged.
   virtual makVrv::DtChannel* targetChannel(makVrv::DtChannel* source);
 
protected:
   //! \brief Handles messages to add a channel association
   //! \param msg Pointer to the association message
   //! \return Message handling result
   //!
   //! Processes messages requesting to add an association between two channels,
   //! updating the channel association map accordingly.
   virtual DtVreMessageResult handleAddChannelEventProcessorAssociation(DtVreMessage* msg);
 
   //! \brief Handles messages to remove a channel association
   //! \param msg Pointer to the disassociation message
   //! \return Message handling result
   //!
   //! Processes messages requesting to remove an association between two channels,
   //! removing the entry from the channel association map.
   virtual DtVreMessageResult handleRemoveChannelEventProcessorAssociation(DtVreMessage* msg);
 
   //! \brief Slot called when a channel is about to be removed
   //! \param channelManager Pointer to the channel manager (unused)
   //! \param channel Pointer to the channel being removed
   //!
   //! Handles cleanup when a channel is being removed, ensuring any
   //! associations involving that channel are also removed.
   virtual void slot_channelToBeRemoved(makVrv::DtChannelManager*, makVrv::DtChannel* channel);
 
   //! \brief Reference to the display engine
   //!
   //! Provides access to display channels and other visualization resources.
   makVrv::DtDe& myDe;
 
   //! \brief Map of source channels to destination channels
   //!
   //! Maintains the associations between source and target channels.
   //! When an event targets a source channel, it can be redirected to
   //! the associated target channel.
   std::map<makVrv::DtChannel*, makVrv::DtChannel*> myChannelAssociations;
};
 
} // namespace makVre