vtkPVOptions.h

Go to the documentation of this file.

/*=========================================================================

  Program:   ParaView
  Module:    vtkPVOptions.h

  Copyright (c) Kitware, Inc.
  All rights reserved.
  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkPVOptions_h
#define vtkPVOptions_h

#include "vtkCommandOptions.h"
#include "vtkRemotingCoreModule.h" //needed for exports

#include <string>  // used for ivar
#include <utility> // needed for pair
#include <vector>  // needed for vector

class vtkPVOptionsInternal;

class VTKREMOTINGCORE_EXPORT vtkPVOptions : public vtkCommandOptions
{
protected:
  friend class vtkPVOptionsXMLParser;

public:
  static vtkPVOptions* New();
  vtkTypeMacro(vtkPVOptions, vtkCommandOptions);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkGetStringMacro(HostName);

  vtkGetMacro(ConnectID, int);
  vtkGetMacro(UseStereoRendering, int);
  vtkGetStringMacro(StereoType);

  vtkGetMacro(ReverseConnection, int);
  vtkGetMacro(UseRenderingGroup, int);
  vtkGetVector2Macro(TileDimensions, int);
  vtkGetVector2Macro(TileMullions, int);

  virtual bool GetIsInTileDisplay() const;

  virtual bool GetIsInCave() const;

  vtkGetMacro(EGLDeviceIndex, int);


  vtkGetStringMacro(ParaViewDataName);


  vtkGetStringMacro(ServersFileName);


  vtkGetMacro(Timeout, int);


  vtkSetMacro(ConnectID, int);


  vtkSetStringMacro(LogFileName);
  vtkGetStringMacro(LogFileName);

  virtual int GetMultiClientMode()
  {
    return (this->MultiClientMode || this->MultiClientModeWithErrorMacro) ? 1 : 0;
  }
  virtual int IsMultiClientModeDebug() { return this->MultiClientModeWithErrorMacro; }


  vtkGetMacro(DisableFurtherConnections, int);


  vtkGetMacro(MultiServerMode, int);


  vtkGetMacro(SymmetricMPIMode, int);
  vtkSetMacro(SymmetricMPIMode, int);


  vtkGetMacro(TellVersion, int);

  vtkGetStringMacro(ServerURL);

  vtkGetMacro(CatalystLivePort, int);


  vtkSetStringMacro(ParaViewDataName);


  vtkSetMacro(EnableStreaming, int);
  vtkGetMacro(EnableStreaming, int);


  vtkSetMacro(SatelliteMessageIds, int);
  vtkGetMacro(SatelliteMessageIds, int);


  vtkGetMacro(PrintMonitors, int);


  vtkGetStringMacro(TestPlugins);
  vtkGetStringMacro(TestPluginPaths);


  vtkGetMacro(EnableStackTrace, int);
  vtkSetMacro(EnableStackTrace, int);


  vtkGetMacro(DisableRegistry, int);


  vtkGetMacro(DisableXDisplayTests, int);

  vtkGetMacro(ForceOffscreenRendering, int);

  vtkGetMacro(ForceOnscreenRendering, int);


  vtkGetMacro(ForceNoMPIInitOnClient, int);
  vtkSetMacro(ForceNoMPIInitOnClient, int);
  vtkBooleanMacro(ForceNoMPIInitOnClient, int);


  vtkGetMacro(ForceMPIInitOnClient, int);
  vtkSetMacro(ForceMPIInitOnClient, int);
  vtkBooleanMacro(ForceMPIInitOnClient, int);


  vtkGetMacro(LogStdErrVerbosity, int);


  const std::string& GetDisplay(int myrank = 0, int num_ranks = 1);

  enum ProcessTypeEnum
  {
    PARAVIEW = 0x2,
    PVCLIENT = 0x4,
    PVSERVER = 0x8,
    PVRENDER_SERVER = 0x10,
    PVDATA_SERVER = 0x20,
    PVBATCH = 0x40,
    ALLPROCESS = PARAVIEW | PVCLIENT | PVSERVER | PVRENDER_SERVER | PVDATA_SERVER | PVBATCH
  };

protected:
  vtkPVOptions();

  ~vtkPVOptions() override;

  void Initialize() override;

  int PostProcess(int argc, const char* const* argv) override;

  int WrongArgument(const char* argument) override;

  int DeprecatedArgument(const char* argument) override;


  char* ParaViewDataName;
  char* ServerURL; // server URL information
  int ServerMode;
  int ClientMode;
  int RenderServerMode;
  int MultiClientMode;
  int DisableFurtherConnections;
  int MultiClientModeWithErrorMacro;
  int MultiServerMode;
  int SymmetricMPIMode;
  char* ServersFileName;
  char* TestPlugins; // to load plugins from command line for tests
  char* TestPluginPaths;
  int DisableXDisplayTests;
  int
    CatalystLivePort; // currently only set through the GUI but may eventually be set in any client

  // inline setters
  vtkSetStringMacro(ServerURL);
  vtkSetStringMacro(ServersFileName);
  vtkSetStringMacro(TestPlugins);
  vtkSetStringMacro(TestPluginPaths);

private:
  int ConnectID;
  int UseOffscreenRendering;
  int EGLDeviceIndex;
  int UseStereoRendering;
  int ReverseConnection;
  int TileDimensions[2];
  int TileMullions[2];
  int UseRenderingGroup;
  int Timeout;
  char* LogFileName;
  int TellVersion;
  char* StereoType;
  int EnableStreaming;
  int SatelliteMessageIds;
  int PrintMonitors;
  int EnableStackTrace;
  int DisableRegistry;
  int ForceMPIInitOnClient;
  int ForceNoMPIInitOnClient;
  int DummyMesaFlag;
  int ForceOffscreenRendering;
  int ForceOnscreenRendering;

  // inline setters
  vtkSetStringMacro(StereoType);

private:
  vtkPVOptions(const vtkPVOptions&) = delete;
  void operator=(const vtkPVOptions&) = delete;

  vtkSetStringMacro(HostName);
  char* HostName;
  int LogStdErrVerbosity;

  std::vector<std::pair<std::string, int> > LogFiles;
  std::vector<std::string> Displays;
  int DisplaysAssignmentMode;

  enum DisplaysAssignmentModeEnum
  {
    CONTIGUOUS,
    ROUNDROBIN
  };

  static int VerbosityArgumentHandler(const char* argument, const char* value, void* call_data);
  static int LogArgumentHandler(const char* argument, const char* value, void* call_data);
  static int DisplaysArgumentHandler(const char* argument, const char* value, void* call_data);
  static int DisplaysAssignmentModeArgumentHandler(
    const char* argument, const char* value, void* call_data);
};

#endif