vtkPVPlugin.h

Go to the documentation of this file.

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

  Program:   ParaView
  Module:    vtkPVPlugin.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 vtkPVPlugin_h
#define vtkPVPlugin_h

#include "vtkObject.h"
#include "vtkPVConfig.h"           // needed for PARAVIEW_VERSION
#include "vtkRemotingCoreModule.h" //needed for exports
#include <string>
#include <vector>

#ifdef _WIN32
// __cdecl gives an unmangled name
#define C_DECL __cdecl
#define C_EXPORT extern "C" __declspec(dllexport)
#elif defined(__GNUC__)
#define C_DECL
#define C_EXPORT extern "C" __attribute__((visibility("default")))
#else
#define C_DECL
#define C_EXPORT extern "C"
#endif

class VTKREMOTINGCORE_EXPORT vtkPVPlugin
{
public:
  vtkPVPlugin();
  virtual ~vtkPVPlugin();

  const char* GetFileName() { return this->FileName; }

  virtual const char* GetPluginName() = 0;

  virtual const char* GetPluginVersionString() = 0;

  virtual bool GetRequiredOnServer() = 0;

  virtual bool GetRequiredOnClient() = 0;

  virtual const char* GetRequiredPlugins() = 0;

  virtual const char* GetDescription() = 0;

  virtual const char* GetEULA() = 0;

  virtual void GetBinaryResources(std::vector<std::string>& resources);


  static bool ImportPlugin(vtkPVPlugin* plugin);

  typedef bool (*EULAConfirmationCallback)(vtkPVPlugin*);


  static void SetEULAConfirmationCallback(EULAConfirmationCallback callback);
  static EULAConfirmationCallback GetEULAConfirmationCallback();

protected:
  void SetFileName(const char* filename);

private:
  static bool ConfirmEULA(vtkPVPlugin* plugin);

  char* FileName;

  static EULAConfirmationCallback EULAConfirmationCallbackPtr;
  friend class vtkPVPluginLoader;

private:
  vtkPVPlugin(const vtkPVPlugin&) = delete;
  void operator=(const vtkPVPlugin&) = delete;
};

#ifndef __WRAP__
typedef vtkPVPlugin*(C_DECL* pv_plugin_query_instance_fptr)();
#endif

#ifdef PARAVIEW_BUILDING_PLUGIN

// vtkPVPluginLoader checks for existence of this function
// to determine if the shared-library is a paraview-server-manager plugin or
// not. The returned value is used to match paraview version/compiler version
// etc. These global functions are added only for shared builds. In static
// builds, plugins cannot be loaded at runtime (only at compile time) so
// verification is not necessary.
#if PARAVIEW_PLUGIN_BUILT_SHARED
#define _PV_PLUGIN_GLOBAL_FUNCTIONS(PLUGIN)                                                        \
  C_EXPORT vtkPVPlugin* C_DECL pv_plugin_instance() { return pv_plugin_instance_##PLUGIN(); }
#else
// define empty export. When building static, we don't want to define the global
// functions.
#define _PV_PLUGIN_GLOBAL_FUNCTIONS(PLUGIN)
#endif

// vtkPVPluginLoader uses this function to obtain the vtkPVPlugin instance  for
// this plugin. In a plugin, there can only be one call to this macro. When
// using the CMake macro ADD_PARAVIEW_PLUGIN, you don't have to worry about
// this, the CMake macro takes care of it.
#define PV_PLUGIN_EXPORT(PLUGIN, PLUGINCLASS)                                                      \
  C_EXPORT vtkPVPlugin* C_DECL pv_plugin_instance_##PLUGIN()                                       \
  {                                                                                                \
    static PLUGINCLASS instance;                                                                   \
    return &instance;                                                                              \
  }                                                                                                \
  _PV_PLUGIN_GLOBAL_FUNCTIONS(PLUGIN);

// PV_PLUGIN_IMPORT_INIT and PV_PLUGIN_IMPORT are provided to make it possible
// to import a plugin at compile time. In static builds, the only way to use a
// plugin is by explicitly importing it using these macros.
// PV_PLUGIN_IMPORT_INIT must be typically placed at after the #include's in a
// cxx file, while PV_PLUGIN_IMPORT must be called at a point after all the
// plugin managers for the application, including the vtkSMPluginManager,
// have been initialized.
#define PV_PLUGIN_IMPORT_INIT(PLUGIN) extern "C" vtkPVPlugin* pv_plugin_instance_##PLUGIN();

#define PV_PLUGIN_IMPORT(PLUGIN) vtkPVPlugin::ImportPlugin(pv_plugin_instance_##PLUGIN());

#endif

#endif // vtkPVPlugin_h
// VTK-HeaderTest-Exclude: vtkPVPlugin.h