RemoteViz/Clients/nodes/SoRemoteVizClient.h

Go to the documentation of this file.

/*=======================================================================
*** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
***                                                                                ***
***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
***                                                                                ***
***                        RESTRICTED RIGHTS LEGEND                                ***
***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
***                                                                                ***
***                   COPYRIGHT (C) 1996-2020 BY FEI S.A.S,                        ***
***                        BORDEAUX, FRANCE                                        ***
***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/

#ifndef _SO_REMOTEVIZ_CLIENT_
#define _SO_REMOTEVIZ_CLIENT_

#if defined(_WIN32) || defined(__WIN32__)
#if !defined( RemoteVizClient_EXPORTS )
#if _DEBUG
#pragma comment(lib,"RemoteVizClientD")
#else
#pragma comment(lib,"RemoteVizClient")
#endif
#endif
#endif

#include <Inventor/sys/port.h>

#include <Inventor/SbPImpl.h>
#include <Inventor/SbString.h>
#include <Inventor/SbVec.h>
#include <Inventor/fields/SoSFString.h>
#include <Inventor/fields/SoSFUShort.h>
#include <Inventor/fields/SoSFBool.h>
#include <Inventor/fields/SoMFVec2String.h>
#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/fields/SoMFEnum.h>
#include <Inventor/nodes/SoNode.h>
#include <Inventor/SbEventHandler.h>
#include <Inventor/SbEventArg.h>

class SoLocation2Event;
class SoMouseButtonEvent;
class SoMouseWheelEvent;
class SoKeyboardEvent;
class SoTouchEvent;
class SoRemoteVizClientImpl;

SO_PIMPL_BASE_PUBLIC_DECLARATION(SoRemoteVizClient);

class RVCLIENT_API SoRemoteVizClient : public SoNode
{

  SO_NODE_HEADER(SoRemoteVizClient);

  SO_PIMPL_BASE_PUBLIC_HEADER(SoRemoteVizClient);

public:

  enum DisplayMode {
    STRETCH    ,
    CROP    ,
    FIT
  };

  enum VideoDecoder {
    NONE,
    OPENH264,
    INTEL_QUICKSYNC,
    NVDECODE
  };

  enum StreamingMode
  {
    /* The streaming mode is not yet known. */
    UNKNOWN,
    /* The client uses image streaming. */
    IMAGE,
    /* The client uses video streaming. */
    VIDEO
  };

  SoRemoteVizClient();

  virtual ~SoRemoteVizClient();

  // Fields:

  SoSFBool connect;

  SoSFString ipAddress;

  SoSFUShort port;

  SoSFString renderAreaName;

  SoMFEnum videoDecoders;

  SoMFVec2String connectionParameters;

  SoSFEnum displayMode;

  void sendMessage(const SbString& message);

  void enableSecureConnection(const SbString& publicCertificateFilePath, const SbString& privateKeyFilePath, unsigned int enabledSecurityProtocols = TLSv1 | TLSv1_1 | TLSv1_2, const SbString& privateKeyPassphrase = "");

  enum SecurityProtocols
  {
    SSLv2 = 0x1, // 2^0, bit 0
    SSLv3 = 0x2, // 2^1, bit 1
    TLSv1 = 0x4, // 2^2, bit 2
    TLSv1_1 = 0x8, // 2^3, bit 3
    TLSv1_2 = 0x10 // 2^4, bit 4
  };

  unsigned int getEnabledSecurityProtocols() const;

  bool isSecureConnection() const;

  void requestRenderAreaSize(const SbVec2s& size);

  SbVec2s getRenderAreaSize();

  SbVec2s getContainerSize();

  bool isImageStreamingSupported();

  bool isVideoStreamingSupported();

  VideoDecoder getVideoDecoder();

  StreamingMode getStreamingMode();

  struct RVCLIENT_API ServiceMessageEventArg : public SbEventArg
  {
    enum State
    {
      CONNECTED,
      DISCONNECTED,
      START_NETWORK_CALIBRATION,
      FINISH_NETWORK_CALIBRATION,
      START_BANDWIDTH_CALIBRATION,
      FINISH_BANDWIDTH_CALIBRATION,
      START_LATENCY_CALIBRATION,
      FINISH_LATENCY_CALIBRATION
    };

    ServiceMessageEventArg(SoRemoteVizClient* source, State state, SbVec2s renderAreaSize, const SbString& details)
      : m_source( source ), m_state( state ), m_renderAreaSize( renderAreaSize ), m_details( &details ) {}

    SoRemoteVizClient* getSource() const { return m_source; }

    State getState() const { return m_state; }

    const SbVec2s& getRenderAreaSize() const { return m_renderAreaSize; }

    const SbString& getDetails() const { return *m_details; }

  private:
    SoRemoteVizClient* m_source;
    State m_state;
    SbVec2s m_renderAreaSize;
    const SbString* m_details;
  };

  struct RVCLIENT_API MessageEventArg : public SbEventArg
  {
    MessageEventArg(SoRemoteVizClient* source, const SbString& message)
      : m_source(source), m_message(&message) {}

    SoRemoteVizClient* getSource() const { return m_source; }

    const SbString& getMessage() const { return *m_message; }

  private:
    SoRemoteVizClient* m_source;
    const SbString* m_message;
  };

  struct RVCLIENT_API RenderAreaSizeEventArg : public SbEventArg
  {
    RenderAreaSizeEventArg(SoRemoteVizClient* source, SbVec2s size)
      : m_source(source), m_size(size) {}

    SoRemoteVizClient* getSource() const { return m_source; }

    const SbVec2s& getSize() const { return m_size; }

    private:
      SoRemoteVizClient* m_source;
      SbVec2s m_size;
  };
  
  struct RVCLIENT_API FrameEventArg : public SbEventArg
  {
    FrameEventArg(SoRemoteVizClient* source, uint64_t id, uint64_t dataLength, bool isLossless, const SbString& message)
      : m_source(source), m_id(id), m_dataLength(dataLength), m_isLossless(isLossless), m_message(&message) {}

    SoRemoteVizClient* getSource() const { return m_source; }

    uint64_t getId() const { return m_id; }

    uint64_t getDataLength() const { return m_dataLength; }

    bool isLossless() const { return m_isLossless; }

    const SbString& getMessage() const { return *m_message; }

    private:
      SoRemoteVizClient* m_source;
      uint64_t m_id;
      uint64_t m_dataLength;
      bool m_isLossless;
      const SbString* m_message;
  };

  struct RVCLIENT_API MouseLocationEventArg : public SbEventArg
  {
    MouseLocationEventArg(SoRemoteVizClient* source, SoLocation2Event* mouseLocationEvent)
      : m_source(source), m_mouseLocationEvent(mouseLocationEvent) {}

    SoRemoteVizClient* getSource() const { return m_source; }

    SoLocation2Event* getMouseLocationEvent() const { return m_mouseLocationEvent; }

    private:
      SoRemoteVizClient* m_source;
      SoLocation2Event* m_mouseLocationEvent;
  };

  struct RVCLIENT_API MouseButtonEventArg : public SbEventArg
  {
    MouseButtonEventArg(SoRemoteVizClient* source, SoMouseButtonEvent* mouseButtonEvent)
      : m_source(source), m_mouseButtonEvent(mouseButtonEvent) {}

    SoRemoteVizClient* getSource() const { return m_source; }

    SoMouseButtonEvent* getMouseButtonEvent() const { return m_mouseButtonEvent; }

    private:
      SoRemoteVizClient* m_source;
      SoMouseButtonEvent* m_mouseButtonEvent;
  };

  struct RVCLIENT_API MouseWheelEventArg : public SbEventArg
  {
    MouseWheelEventArg(SoRemoteVizClient* source, SoMouseWheelEvent* mouseWheelEvent)
      : m_source(source), m_mouseWheelEvent(mouseWheelEvent) {}

    SoRemoteVizClient* getSource() const { return m_source; }

    SoMouseWheelEvent* getMouseWheelEvent() const { return m_mouseWheelEvent; }

    private:
      SoRemoteVizClient* m_source;
      SoMouseWheelEvent* m_mouseWheelEvent;
  };

  struct RVCLIENT_API KeyboardEventArg : public SbEventArg
  {
    KeyboardEventArg(SoRemoteVizClient* source, SoKeyboardEvent* keyboardEvent)
      : m_source(source), m_keyboardEvent(keyboardEvent) {}

    SoRemoteVizClient* getSource() const { return m_source; }

    SoKeyboardEvent* getKeyboardEvent() const { return m_keyboardEvent; }

    private:
      SoRemoteVizClient* m_source;
      SoKeyboardEvent* m_keyboardEvent;
  };

  struct RVCLIENT_API TouchEventArg : public SbEventArg
  {
    TouchEventArg(SoRemoteVizClient* source, SoTouchEvent* touchEvent)
      : m_source(source), m_touchEvent(touchEvent) {}

    SoRemoteVizClient* getSource() const { return m_source; }

    SoTouchEvent* getTouchEvent() const { return m_touchEvent; }

    private:
      SoRemoteVizClient* m_source;
      SoTouchEvent* m_touchEvent;
  };

  SbEventHandler<ServiceMessageEventArg&> onServiceMessage;

  SbEventHandler<MessageEventArg&> onReceivedMessage;

  SbEventHandler<RenderAreaSizeEventArg&> onRenderAreaResize;

  SbEventHandler<FrameEventArg&> onReceivedFrame;

  SbEventHandler<FrameEventArg&> onDecodedFrame;

  SbEventHandler<MouseLocationEventArg&> onMouseLocationEvent;

  SbEventHandler<MouseButtonEventArg&> onMouseButtonEvent;

  SbEventHandler<MouseWheelEventArg&> onMouseWheelEvent;

  SbEventHandler<KeyboardEventArg&> onKeyboardEvent;

  SbEventHandler<TouchEventArg&> onTouchEvent;

  private:
  // Initializes this class
  static void       initClass();
  static void       exitClass();

private:
  virtual void notify(SoNotList *list);

  virtual void doAction(SoAction *action);

  virtual void GLRender(SoGLRenderAction *action);

  virtual void handleEvent(SoHandleEventAction *action);


private:

  void construct();
};

#endif // _SO_REMOTEVIZ_CLIENT_

---

Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/