ParaView-5.0.1: Added the source-tree to ThirdParty-dev and patched as described in the README file

Resolves bug-report http://bugs.openfoam.org/view.php?id=2098

ParaView-5.0.1/ParaViewCore/ClientServerCore/Rendering/vtkPVSynchronizedRenderWindows.h

@@ -0,0 +1,290 @@
+/*=========================================================================
+
+  Program:   ParaView
+  Module:    vtkPVSynchronizedRenderWindows.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.
+
+=========================================================================*/
+// .NAME vtkPVSynchronizedRenderWindows - synchronizes render-windows among
+// processes in ParaView configurations.
+// .SECTION Description
+// vtkPVSynchronizedRenderWindows is the class used to synchronize render
+// windows in ParaView. This class can be instantiated on all processes in all
+// modes, it automatically discovers the configuration and adapts its behavior
+// accordingly. The role of this class is to set up the render windows on all
+// processes and then synchronize renders. It does not manage compositing or
+// image delivery. All it does is synchronize render windows and their layouts
+// among processes.
+//
+// If the application is managing calling of vtkRenderWindow::Render() on all
+// processes, then one should disable RenderEventPropagation flag.
+
+#ifndef vtkPVSynchronizedRenderWindows_h
+#define vtkPVSynchronizedRenderWindows_h
+
+#include "vtkPVClientServerCoreRenderingModule.h" //needed for exports
+#include "vtkObject.h"
+#include "vtkMultiProcessController.h" // for vtkRMIFunctionType
+#include "vtkWeakPointer.h" // for vtkWeakPointer.
+
+class vtkDataObject;
+class vtkMultiProcessController;
+class vtkMultiProcessStream;
+class vtkPVSession;
+class vtkRenderer;
+class vtkRenderWindow;
+class vtkSelection;
+
+class VTKPVCLIENTSERVERCORERENDERING_EXPORT vtkPVSynchronizedRenderWindows : public vtkObject
+{
+public:
+  // Description:
+  // if session==NULL, then active session is used. If no active session is
+  // present, then it's a critical error and this method will return NULL.
+  static vtkPVSynchronizedRenderWindows* New(vtkPVSession* session=NULL);
+
+  vtkTypeMacro(vtkPVSynchronizedRenderWindows, vtkObject);
+  void PrintSelf(ostream& os, vtkIndent indent);
+
+  // Description:
+  // Returns a render window for use (possibly new).
+  virtual vtkRenderWindow* NewRenderWindow();
+
+  // Description:
+  // Register/UnRegister a window.
+  virtual void AddRenderWindow(unsigned int id, vtkRenderWindow*);
+  virtual void RemoveRenderWindow(unsigned int id);
+  vtkRenderWindow* GetRenderWindow(unsigned int id);
+
+  // Description:
+  // Register/UnRegister the renderers. One can add multiple renderers for the
+  // same id. The id must be same as that specified when adding the
+  // corresponding render window.
+  virtual void AddRenderer(unsigned int id, vtkRenderer*);
+  virtual void RemoveAllRenderers(unsigned int id);
+  virtual void AddRenderer(unsigned int id, vtkRenderer*, const double viewport[4]);
+  virtual bool UpdateRendererViewport(unsigned int id, vtkRenderer*, const double viewport[4]);
+
+  // Description:
+  // The views are not supposed to updated the render window position or size
+  // directly. They should always go through this API to update the window sizes
+  // and positions. This makes it possible to provide a consistent API
+  // irrespective of the mode ParaView is running in.
+  // These methods only need to be called on the "driver" node. (No harm in
+  // calling on all nodes). By driver node, we mean the CLIENT in
+  // client-server mode and the root node in batch mode.
+  virtual void SetWindowSize(unsigned int id, int width, int height);
+  virtual void SetWindowPosition(unsigned int id, int posx, int posy);
+  virtual const int* GetWindowSize(unsigned int id);
+  virtual const int* GetWindowPosition(unsigned int id);
+
+  // Description:
+  // Enable/Disable parallel rendering.
+  vtkSetMacro(Enabled, bool);
+  vtkGetMacro(Enabled, bool);
+  vtkBooleanMacro(Enabled, bool);
+
+  // Description:
+  // Enable/Disable propagation of the render event. This is typically true,
+  // unless the application is managing calling Render() on all processes
+  // involved.
+  vtkSetMacro(RenderEventPropagation, bool);
+  vtkGetMacro(RenderEventPropagation, bool);
+  vtkBooleanMacro(RenderEventPropagation, bool);
+
+  // Description:
+  // This method returns true if the local process is the 'driver' process. In
+  // client-server configurations, client is the driver. In batch
+  // configurations, root-node is the driver. In built-in mode, this always
+  // returns true.
+  bool GetLocalProcessIsDriver();
+
+  // Description:
+  // vtkPVSynchronizedRenderWindows encapsulates a whole lot of logic for
+  // communication between processes. Given the ton of information this class
+  // keeps, it can easily aid vtkViews to synchronize information such as bounds/
+  // data-size among all processes efficiently. This can be achieved by using
+  // these methods.
+  // Note that these methods should be called on all processes at the same time
+  // otherwise we will have deadlocks.
+  // We may make this API generic in future, for now this works.
+  bool SynchronizeBounds(double bounds[6]);
+  bool SynchronizeSize(double &size);
+  bool SynchronizeSize(unsigned int &size);
+  bool BroadcastToDataServer(vtkSelection* selection);
+  bool BroadcastToRenderServer(vtkDataObject*);
+
+  enum StandardOperations
+    {
+    MAX_OP = vtkCommunicator::MAX_OP,
+    MIN_OP = vtkCommunicator::MIN_OP,
+    SUM_OP = vtkCommunicator::SUM_OP
+    };
+  bool Reduce(vtkIdType& value, StandardOperations operation);
+
+  // Description:
+  // Convenience method to trigger an RMI call from the client/root node.
+  void TriggerRMI(vtkMultiProcessStream& stream, int tag);
+  unsigned long AddRMICallback(vtkRMIFunctionType, void* localArg, int tag);
+  bool RemoveRMICallback(unsigned long id);
+
+//BTX
+  enum
+    {
+    SYNC_MULTI_RENDER_WINDOW_TAG = 15002,
+    GET_ZBUFFER_VALUE_TAG = 15003,
+    SYNC_TILE_DISPLAY_PARAMATERS = 15004
+    };
+
+  // Internal-callback-method
+  void Render(unsigned int);
+  void OnGetZBufferValue(unsigned int, int, int);
+
+  // Description:
+  vtkGetObjectMacro(ParallelController, vtkMultiProcessController);
+  vtkGetObjectMacro(ClientServerController, vtkMultiProcessController);
+  vtkGetObjectMacro(ClientDataServerController, vtkMultiProcessController);
+
+  // Description:
+  // By default, this class uses the same render window for all views on the
+  // server processes and then arranges the renderers by adjusting their
+  // viewports. However, this does not work well when doing image capture with
+  // magnification. In those cases, you can force this class to simply render
+  // the active view as the sole view in the window on the server side by
+  // setting this flag to true.
+  vtkSetMacro(RenderOneViewAtATime, bool);
+  vtkGetMacro(RenderOneViewAtATime, bool);
+  vtkBooleanMacro(RenderOneViewAtATime, bool);
+
+  // Description:
+  // Called before starting render. This is needed in batch mode since all views
+  // share the same render window.
+  void BeginRender(unsigned int id);
+
+  // Description:
+  // Returns true when in Cave mode.
+  bool GetIsInCave();
+
+  // Description:
+  // This method should only be called on RENDER_SERVER or BATCH processes.
+  // Returns true if in tile display mode and fills up tile_dims with the tile
+  // dimensions.
+  bool GetTileDisplayParameters(int tile_dims[2], int tile_mullions[2]);
+
+  // Description:
+  // Returns the z-buffer value at the given location. \c id is the view id
+  // used in AddRenderWindow()/AddRenderer() etc.
+  // @CallOnClientOnly
+  double GetZbufferDataAtPoint(int x, int y, unsigned int id);
+
+  enum ModeEnum
+    {
+    INVALID,
+    BUILTIN,
+    CLIENT,
+    RENDER_SERVER,
+    DATA_SERVER,
+    BATCH
+    };
+
+  // Description:
+  // Streaming uses this class as a conduit for messaging.
+  // Need mode to use it correctly.
+  ModeEnum GetMode() { return this->Mode; };
+
+  // Description:
+  // Provides access to the session.
+  vtkPVSession* GetSession();
+
+protected:
+  vtkPVSynchronizedRenderWindows(vtkPVSession*);
+  ~vtkPVSynchronizedRenderWindows();
+
+  // Description:
+  // Set/Get the controller used for communication among parallel processes.
+  void SetParallelController(vtkMultiProcessController*);
+
+  // Description:
+  // Set/Get the controller used for client-server communication.
+  void SetClientServerController(vtkMultiProcessController*);
+
+  // Description:
+  // Set/Get the controller used for client-data-server communication.
+  void SetClientDataServerController(vtkMultiProcessController*);
+
+  // Description:
+  // Saves the information about all the windows known to this class and how
+  // they are laid out. For this to work as expected, it is essential that the
+  // client sets the WindowSize and WindowPosition correctly for all the render
+  // windows using the API on this class. It also saves some information about
+  // the active render window.
+  void SaveWindowAndLayout(vtkRenderWindow*, vtkMultiProcessStream& stream);
+  void LoadWindowAndLayout(vtkRenderWindow*, vtkMultiProcessStream& stream);
+
+  // Description:
+  // Using the meta-data saved about the render-windows and their positions and
+  // sizes, this updates the renderers/window-sizes etc. This have different
+  // response on different processes types.
+  void UpdateWindowLayout();
+
+  // Description:
+  // Ensures that only the renderer assigned to the given id are enabled, all
+  // others are disabled. This is especially necessary on processes where the
+  // render window is shared.
+  void UpdateRendererDrawStates(unsigned int id);
+
+  // These methods are called on all processes as a consequence of corresponding
+  // events being called on the render window.
+  virtual void HandleStartRender(vtkRenderWindow*);
+  virtual void HandleEndRender(vtkRenderWindow*);
+  virtual void HandleAbortRender(vtkRenderWindow*) {}
+
+  virtual void ClientStartRender(vtkRenderWindow*);
+  virtual void RootStartRender(vtkRenderWindow*);
+  virtual void SatelliteStartRender(vtkRenderWindow*);
+
+  // Description:
+  // Shrinks gaps between views, rather grows the views to reduce gaps. Only
+  // used in tile-display mode to avoid gaps on the server side.
+  void ShinkGaps();
+
+
+  ModeEnum Mode;
+  vtkMultiProcessController* ParallelController;
+  vtkMultiProcessController* ClientServerController;
+  vtkMultiProcessController* ClientDataServerController;
+  unsigned long ClientServerRMITag;
+  unsigned long ClientServerGetZBufferValueRMITag;
+  unsigned long ParallelRMITag;
+  bool Enabled;
+  bool RenderEventPropagation;
+  bool RenderOneViewAtATime;
+
+  vtkWeakPointer<vtkPVSession> Session;
+
+private:
+  vtkPVSynchronizedRenderWindows(const vtkPVSynchronizedRenderWindows&); // Not implemented
+  void operator=(const vtkPVSynchronizedRenderWindows&); // Not implemented
+
+  class vtkInternals;
+  vtkInternals* Internals;
+
+  class vtkObserver;
+  vtkObserver* Observer;
+
+
+  template <class T>
+  bool ReduceTemplate(T &size, StandardOperations operation);
+//ETX
+};
+
+#endif
+
+// VTK-HeaderTest-Exclude: vtkPVSynchronizedRenderWindows.h