vtkSMViewProxy.h

Go to the documentation of this file.

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

  Program:   ParaView
  Module:    vtkSMViewProxy.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 vtkSMViewProxy_h
#define vtkSMViewProxy_h

#include "vtkCommand.h"             // needed for vtkCommand.
#include "vtkRemotingViewsModule.h" //needed for exports
#include "vtkSMProxy.h"

class vtkImageData;
class vtkRenderer;
class vtkRenderWindow;
class vtkRenderWindowInteractor;
class vtkSMDataDeliveryManagerProxy;
class vtkSMRepresentationProxy;
class vtkSMSourceProxy;
class vtkView;

namespace vtkSMViewProxyNS
{
class WindowToImageFilter;
class CaptureHelper;
}

class VTKREMOTINGVIEWS_EXPORT vtkSMViewProxy : public vtkSMProxy
{
public:
  static vtkSMViewProxy* New();
  vtkTypeMacro(vtkSMViewProxy, vtkSMProxy);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkSetMacro(Enable, bool);
  vtkGetMacro(Enable, bool);
  vtkBooleanMacro(Enable, bool);

  virtual void StillRender();

  virtual void InteractiveRender();

  virtual void Update();

  virtual bool CanDisplayData(vtkSMSourceProxy* producer, int outputPort);

  virtual vtkSMRepresentationProxy* CreateDefaultRepresentation(vtkSMProxy*, int);

  virtual const char* GetRepresentationType(vtkSMSourceProxy* producer, int outputPort);

  virtual vtkSMRepresentationProxy* FindRepresentation(vtkSMSourceProxy* producer, int outputPort);


  vtkImageData* CaptureWindow(int magnification)
  {
    return this->CaptureWindow(magnification, magnification);
  }
  vtkImageData* CaptureWindow(int magnificationX, int magnificationY);

  vtkView* GetClientSideView();

  int WriteImage(const char* filename, const char* writerName, int magnification = 1);
  int WriteImage(
    const char* filename, const char* writerName, int magnificationX, int magnificationY);

  virtual bool HasDirtyRepresentation() { return this->GetNeedsUpdate(); }


  vtkGetMacro(NeedsUpdate, bool);

  virtual vtkRenderWindow* GetRenderWindow() { return NULL; }

  virtual vtkRenderWindowInteractor* GetInteractor() { return NULL; }

  virtual void SetupInteractor(vtkRenderWindowInteractor* iren) { (void)iren; }

  virtual bool MakeRenderWindowInteractor(bool quiet = false);


  static void SetTransparentBackground(bool val);
  static bool GetTransparentBackground();


  virtual bool HideOtherRepresentationsIfNeeded(vtkSMProxy* repr);
  static bool HideOtherRepresentationsIfNeeded(vtkSMViewProxy* self, vtkSMProxy* repr)
  {
    return self ? self->HideOtherRepresentationsIfNeeded(repr) : false;
  }


  virtual void RepresentationVisibilityChanged(vtkSMProxy* repr, bool new_visibility);
  static void RepresentationVisibilityChanged(
    vtkSMViewProxy* self, vtkSMProxy* repr, bool new_visibility)
  {
    if (self)
    {
      self->RepresentationVisibilityChanged(repr, new_visibility);
    }
  }

  static vtkSMViewProxy* FindView(vtkSMProxy* repr, const char* reggroup = "views");

  enum
  {
    PrepareContextForRendering = vtkCommand::UserEvent + 1,
  };

protected:
  vtkSMViewProxy();
  ~vtkSMViewProxy() override;

  virtual vtkImageData* CaptureWindowInternal(int magnificationX, int magnificationY);

  virtual void RenderForImageCapture() { this->StillRender(); }

  virtual vtkTypeUInt32 PreRender(bool vtkNotUsed(interactive)) { return this->GetLocation(); }

  virtual void PostRender(bool vtkNotUsed(interactive)) {}

  virtual bool IsContextReadyForRendering();

  void CreateVTKObjects() override;

  int ReadXMLAttributes(vtkSMSessionProxyManager* pm, vtkPVXMLElement* element) override;

  bool GetLocalProcessSupportsInteraction();

  vtkGetObjectMacro(DeliveryManager, vtkSMDataDeliveryManagerProxy);

  vtkSetStringMacro(DefaultRepresentationName);
  char* DefaultRepresentationName;

  bool Enable;

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

  vtkSMDataDeliveryManagerProxy* DeliveryManager;
  static bool TransparentBackground;

  // Actual logic for taking a screenshot.
  vtkImageData* CaptureWindowSingle(int magnificationX, int magnificationY);

  friend class vtkSMViewProxyNS::WindowToImageFilter;
  friend class vtkSMViewProxyNS::CaptureHelper;
};

#endif