GUI/Client/vtkPVSource.h

Go to the documentation of this file.

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

  Program:   ParaView
  Module:    $RCSfile: vtkPVSource.h,v $

  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 __vtkPVSource_h
#define __vtkPVSource_h

#include "vtkPVTracedWidget.h"
#include "vtkClientServerStream.h"  // needed for vtkClientServerID

class vtkCollection;
class vtkKWFrame;
class vtkKWFrameWithScrollbar;
class vtkKWView;
class vtkPVApplication;
class vtkPVColorMap;
class vtkPVDataInformation;
class vtkPVDataSetAttributesInformation;
class vtkPVDisplayGUI;
class vtkPVInputProperty;
class vtkPVLookmark;
class vtkPVNumberOfOutputsInformation;
class vtkPVRenderView;
class vtkPVSourceNotebook;
class vtkPVWidget;
class vtkPVWidgetCollection;
class vtkPVWindow;
class vtkSMCubeAxesDisplayProxy;
class vtkSMDataObjectDisplayProxy;
class vtkSMDisplayProxy;
class vtkSMPart;
class vtkSMPointLabelDisplayProxy;
class vtkSMSourceProxy;
class vtkSource;
class vtkStringList;


class VTK_EXPORT vtkPVSource : public vtkPVTracedWidget
{
public:
  static vtkPVSource* New();
  vtkTypeRevisionMacro(vtkPVSource,vtkPVTracedWidget);
  void PrintSelf(ostream& os, vtkIndent indent);
  
  vtkPVWindow *GetPVWindow();
  
  virtual void CreateProperties();

  void Update();


  virtual void Select();
  virtual void Deselect(int doPackForget = 1);
  virtual void Pack();


  void SetVisibility(int v);
  int GetVisibility();
  virtual void SetVisibilityNoTrace(int v);
  
  void SetPVColorMap(vtkPVColorMap *colorMap);  
  
  void SetDefaultColorParameters();
  

  void SetCubeAxesVisibility(int val);
  void SetCubeAxesVisibilityNoTrace(int val);
  vtkGetMacro(CubeAxesVisibility, int);


  void SetPointLabelVisibility(int val);
  void SetPointLabelVisibilityNoTrace(int val);
  vtkGetMacro(PointLabelVisibility, int);

  void SetPointLabelFontSize(int val);
  void SetPointLabelFontSizeNoTrace(int val);
  vtkGetMacro(PointLabelFontSize, int);


  void AddPVInput(vtkPVSource *input);
  void SetPVInput(const char* name, int idx, vtkPVSource *input);

  vtkPVSource* GetPVInput(int idx) {return this->GetNthPVInput(idx);}


  vtkGetMacro(NumberOfPVInputs, int);

  void RemoveAllPVInputs();


  vtkGetMacro(NumberOfPVConsumers, int);


  void AddPVConsumer(vtkPVSource *c);
  void RemovePVConsumer(vtkPVSource *c);
  vtkPVSource *GetPVConsumer(int i);
  int IsPVConsumer(vtkPVSource *c);

  vtkPVDisplayGUI* GetPVOutput();
  

  vtkGetObjectMacro(PVColorMap, vtkPVColorMap);
   

  virtual void SetName(const char *name);
  char* GetName();


  vtkSetMacro(OverideAutoAccept,int);
  vtkGetMacro(OverideAutoAccept,int);
    

  virtual void SetLabelNoTrace(const char *label);
  virtual void SetLabel(const char *label);
  virtual char* GetLabel();
  virtual void SetLabelOnce(const char *label);
    
  vtkPVApplication* GetPVApplication();  


  void AcceptCallback();
  virtual void PreAcceptCallback();

  virtual int IsDeletable();


  virtual void Accept() { this->Accept(0); }
  virtual void Accept(int hideFlag) { this->Accept(hideFlag, 1); }
  virtual void Accept(int hideFlag, int hideSource);
  
  void ResetCallback();

  virtual void DeleteCallback();

  virtual void Reset();
  
  void UpdateProperties();  

  virtual void UpdateVTKSourceParameters();

  //BTX

  void AddVTKSource(vtkClientServerID);
  //ETX

  int GetNumberOfVTKSources();

  //BTX

  vtkClientServerID GetVTKSourceID(int idx);
  //ETX
  // Description:
  // Give an index, return the ID of a VTK source as unsigned int.
  unsigned int GetVTKSourceIDAsInt(int idx);

  //BTX
  vtkGetObjectMacro(Widgets, vtkPVWidgetCollection);
  //ETX
  
  virtual void SaveInBatchScript(ofstream *file);


  virtual void SaveState(ofstream *file);
  virtual void SaveStateVisibility(ofstream *file);
  virtual void SaveStateDisplay(ofstream *file);
  

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

  vtkPVWidget *GetPVWidget(const char *name);

  vtkPVSource **GetPVInputs() { return this->PVInputs; };


  void SetNotebook(vtkPVSourceNotebook* notebook);
  vtkGetObjectMacro(Notebook, vtkPVSourceNotebook);


  vtkSetMacro(VisitedFlag,int);
  vtkGetMacro(VisitedFlag,int);

  void AddPVWidget(vtkPVWidget *pvw);

  int CloneAndInitialize(int makeCurrent, vtkPVSource*& clone);

  int ClonePrototype(vtkPVSource*& clone);

  virtual int InitializeClone(int makeCurrent);

  virtual int InitializeData();  

  virtual void InitializePrototype() {}


  vtkSetStringMacro(SourceClassName);
  vtkGetStringMacro(SourceClassName);


  vtkSMPart *GetPart() {return this->GetPart(0);} 
  vtkSMPart *GetPart(int idx); 
  int GetNumberOfParts();


  vtkIdType GetNumberOfInputProperties();
  vtkPVInputProperty* GetInputProperty(int idx);
  vtkPVInputProperty* GetInputProperty(const char* name);


  vtkSetMacro(VTKMultipleInputsFlag, int);
  vtkGetMacro(VTKMultipleInputsFlag, int);
  

  vtkSetMacro(VTKMultipleProcessFlag, int);
  vtkGetMacro(VTKMultipleProcessFlag, int);
  
  int GetNumberOfProcessorsValid();
  

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


  vtkSetStringMacro(ModuleName);
  vtkGetStringMacro(ModuleName);


  vtkSetStringMacro(MenuName);
  vtkGetStringMacro(MenuName);


  vtkSetStringMacro(ShortHelp);
  vtkGetStringMacro(ShortHelp);


  vtkSetStringMacro(LongHelp);
  vtkGetStringMacro(LongHelp);


  vtkGetMacro(Initialized, int);


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


  void GrabFocus();
  void UnGrabFocus();

  vtkPVDataInformation* GetDataInformation();
  
  void InvalidateDataInformation();

  vtkPVRenderView *GetPVRenderView();


  vtkGetObjectMacro(NumberOfOutputsInformation,
                    vtkPVNumberOfOutputsInformation);

  virtual void UpdateEnableState();


  vtkGetMacro(SourceGrabbed, int);
 

  void SetProxy(vtkSMSourceProxy* proxy);
  vtkGetObjectMacro(Proxy, vtkSMSourceProxy);

  void RegisterProxy(const char* sourceList, vtkPVSource* clone);

  virtual void UpdateVTKObjects();
  

  void SetDisplayProxy(vtkSMDataObjectDisplayProxy* pdisp);
  vtkGetObjectMacro(DisplayProxy, vtkSMDataObjectDisplayProxy);


  vtkGetObjectMacro(PointLabelDisplayProxy, vtkSMPointLabelDisplayProxy);

  void VolumeRenderByArray(const char* arrayname, int field);

  void ColorByArray(const char* arrayname, int field);

  void SetAcceptButtonColorToModified();

  void MarkSourcesForUpdate();


  void SetLookmark(vtkPVLookmark *lookmark);
  vtkGetObjectMacro(Lookmark,vtkPVLookmark);

protected:
  vtkPVSource();
  ~vtkPVSource();


  virtual void SetupDisplays();
  virtual void CleanupDisplays();

  void ColorByArray(vtkPVColorMap* colorMap, int field);

  void SetPVInputInternal(const char* name, 
                          int idx, 
                          vtkPVSource *input, 
                          int doInit);

  void SaveFilterInBatchScript(ofstream *file);

  virtual void InitializeWidgets();  


  vtkPVColorMap *PVColorMap;
  
  int DataInformationValid;

  vtkPVNumberOfOutputsInformation *NumberOfOutputsInformation;
  
  // This flag gets set after the user hits accept for the first time.
  int Initialized;

  // This is different than the CubeAxesDisplay visibility.
  // This is the state of the user selection. The CubeAxesDisplay
  // visibility is the value "visibility and CubeAxesVisibility".
  int CubeAxesVisibility;

  // This is different than the PointLabelDisplay visibility.
  // This is the state of the user selection. The PointLabelDisplay
  // visibility is the value "visibility and PointLabelVisibility".
  int PointLabelVisibility;
  int PointLabelFontSize;

  vtkKWFrameWithScrollbar *ParameterFrame;
  vtkSMDataObjectDisplayProxy* DisplayProxy;


  void AddDisplayToRenderModule(vtkSMDisplayProxy* pDisp);
  void RemoveDisplayFromRenderModule(vtkSMDisplayProxy* pDisp);

  // Called to allocate the input array.  Copies old inputs.
  void SetNumberOfPVInputs(int num);
  vtkPVSource **PVInputs;
  int NumberOfPVInputs; 
  vtkPVSource *GetNthPVInput(int idx);
  void SetNthPVInput(int idx, vtkPVSource *input);

  // Keep a list of sources that are using this data.
  vtkPVSource **PVConsumers;
  int NumberOfPVConsumers;
     
  // The real AcceptCallback method.
  virtual void AcceptCallbackInternal();
  
  vtkPVSourceNotebook *Notebook;
  // Since the notebook is share between all sources,
  // we remember the raised page to restore when the source is selected.
  // This ivar is set and used by vtkPVWindow.
  int SavedRaisedNotebookPageId;

  char* SourceList;
  vtkSetStringMacro(SourceList);
  vtkGetStringMacro(SourceList);

  // The name is just for display.
  char      *Name;
  char      *MenuName;
  char      *Label;
  char      *ShortHelp;
  char      *LongHelp;
  int       OverideAutoAccept;

  // This is the module name.
  char      *ModuleName;

  
  vtkPVWidgetCollection *Widgets;

  char *SourceClassName;

  vtkSMSourceProxy* Proxy;

  // Whether the source should make its input invisible.
  int ReplaceInput;

  int VisitedFlag;

  // Number of instances cloned from this prototype
  int PrototypeInstanceCount;

  int IsPermanent;
  
  // Flag for whether we are currently in AcceptCallback.
  int AcceptCallbackFlag;

  // Flag to tell whether the source is grabbed or not.
  int SourceGrabbed;

  virtual int ClonePrototypeInternal(vtkPVSource*& clone);

  int ToolbarModule;

  // This ivar is here so that Probe will not have any sources which
  // have more than one part. A value of -1 means no restrictions.
  int RequiredNumberOfInputParts;
  // This value is set by the xml <input quantity="..."/> attributes
  // to characterize the VTK source.  a value of 1 (set by "Multiple")
  // indicates any number of inputs can be had with the AddInput method.
  int VTKMultipleInputsFlag;
  vtkCollection* InputProperties;

  int VTKMultipleProcessFlag;
  
  // Taking responsibility of saving inputs away from input menu.
  void SetInputsInBatchScript(ofstream *file);

  int UpdateSourceInBatch;

  int LabelSetByUser;
  int ResetInSelect;
  
  // CubeAxes should be moved into a display of its own.
  vtkSMCubeAxesDisplayProxy* CubeAxesDisplayProxy;
  vtkSMPointLabelDisplayProxy* PointLabelDisplayProxy;

//BTX
  friend class vtkPVWindow;
//ETX 

  vtkPVLookmark *Lookmark;

  int ColorByScalars(
    vtkPVDataSetAttributesInformation* attrInfo,
    vtkPVDataSetAttributesInformation* inAttrInfo,
    int field);

private:
  vtkPVSource(const vtkPVSource&); // Not implemented
  void operator=(const vtkPVSource&); // Not implemented
};

#endif

---