GUI/Client/vtkPVWindow.h

Go to the documentation of this file.

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

  Program:   ParaView
  Module:    $RCSfile: vtkPVWindow.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 __vtkPVWindow_h
#define __vtkPVWindow_h

#include "vtkKWWindow.h"

#include "vtkClientServerID.h" // Needed for InteractorID

class vtkCollection;
class vtkPVGenericRenderWindowInteractor;
class vtkKWCheckButton;
class vtkKWEntry;
class vtkKWFrame;
class vtkKWLabel;
class vtkKWPushButton;
class vtkKWPushButtonWithMenu;
class vtkKWMenuButton;
class vtkKWRadioButton;
class vtkKWRotateCameraInteractor;
class vtkKWToolbar;
class vtkPVAnimationInterface;
class vtkPVApplication;
class vtkPVApplicationSettingsInterface;
class vtkPVCameraManipulator;
class vtkPVColorMap;
class vtkPVComparativeVisManagerGUI;
class vtkPVErrorLogDisplay;
class vtkPVInteractorStyle;
class vtkPVInteractorStyleCenterOfRotation;
class vtkPVLookmarkManager;
class vtkPVReaderModule;
class vtkPVRenderView;
class vtkPVSource;
class vtkPVSourceCollection;
class vtkPVTimerLogDisplay;
class vtkPVTrackballRoll;
class vtkPVVolumeAppearanceEditor;
class vtkPVWidget;
class vtkPVWriter;
class vtkPVXMLPackageParser;
class vtkSMAxesProxy;
class vtkKWSplitFrame;
class vtkPVTraceHelper;

class vtkPVAnimationManager;
class vtkKWToolbarSet;

//BTX
template <class key, class data> 
class vtkArrayMap;
template <class value>
class vtkLinkedList;
//ETX

#define VTK_PV_SOURCE_MENU_INDEX       2
#define VTK_PV_SOURCE_MENU_LABEL       " Source"
#define VTK_PV_ANIMATION_MENU_INDEX    3
#define VTK_PV_ANIMATION_MENU_LABEL    " Animation"

class VTK_EXPORT vtkPVWindow : public vtkKWWindow
{
public:
  static vtkPVWindow* New();
  vtkTypeRevisionMacro(vtkPVWindow,vtkKWWindow);
  void PrintSelf(ostream& os, vtkIndent indent);

  virtual void Create(vtkKWApplication *app);


  vtkGetObjectMacro(MainView, vtkPVRenderView);


  void SetCurrentPVSource(vtkPVSource *comp);
  void SetCurrentPVSourceCallback(vtkPVSource *comp);
  vtkPVSource *GetCurrentPVSource() {return this->CurrentPVSource;}
  vtkPVSource *GetPreviousPVSource(int idx = 1);
  vtkPVReaderModule *GetCurrentPVReaderModule();

  void AddPVSource(const char* listname, vtkPVSource *pvs);

  void RemovePVSource(const char* listname, vtkPVSource *pvs);


  void DeleteAllSourcesCallback();
  void DeleteAllSources();
  void DeleteSourceAndOutputs(vtkPVSource*);


  void DeleteAllKeyframesCallback();
  void DeleteAllKeyframes();
    
  vtkPVSource *GetPVSource(const char* listname, const char* sourcename);


  vtkGetObjectMacro(SelectMenu, vtkKWMenu);
  vtkGetObjectMacro(GlyphMenu, vtkKWMenu);
  vtkGetObjectMacro(SourceMenu, vtkKWMenu);
  vtkGetObjectMacro(FilterMenu, vtkKWMenu);
  
  void ResetCameraCallback();
  

  void ShowCurrentSourceProperties();
  void ShowCurrentSourcePropertiesCallback();

  void ShowAnimationPanes();


  vtkGetObjectMacro(Toolbar, vtkKWToolbar);
  vtkGetObjectMacro(InteractorToolbar, vtkKWToolbar);
  vtkGetObjectMacro(PickCenterToolbar, vtkKWToolbar);
  vtkGetObjectMacro(LookmarkToolbar, vtkKWToolbar);
 

  void SaveBatchScript(const char *filename);
  void SaveBatchScript(const char *filename, int offScreenFlag, const char* imageFileName, const char* geometryFileName);
  

  void SaveSMState();
  void SaveSMState(const char *filename);
  
  void SaveBatchScript();

  void SaveState(const char *filename);

  void SaveState();


  void SaveTrace();
  int SaveTrace(const char*);
  
  void OpenCallback();


  int Open(char *fileName, int store);
  int Open(char *fileName) { return this->Open(fileName, 0); }

  int OpenCustom(const char* reader, const char* filename);


  vtkPVReaderModule* InitializeReadCustom(const char* reader, 
                                          const char* fileName);
  int FinalizeRead       (vtkPVReaderModule* clone, const char *fileName);
  int ReadFileInformation(vtkPVReaderModule* clone, const char *fileName);

  void PlayDemo();


  void ShowTimerLog();
  void ShowErrorLog();

  void ShowComparativeVisManager();
 
  void SaveAnimation();

  void SaveGeometry();

  void WriteData();
  

  void WriteVTKFile(const char* filename, int ghostLevel, int timeSeries);
  void WriteVTKFile(const char* filename, int ghostLevel)
    { this->WriteVTKFile(filename, ghostLevel, 0); }
  void WriteVTKFile(const char* filename)
    { this->WriteVTKFile(filename, 0); }


  vtkPVSource *CreatePVSource(const char *className)
    { return this->CreatePVSource(className, 0, 1, 1); }
  vtkPVSource *CreatePVSource(const char *className, const char* sourceList)
    { return this->CreatePVSource(className, sourceList, 1, 1); }
  vtkPVSource *CreatePVSource(const char *className, const char* sourceList,
                              int add_trace_entry, int grabFocus);
  
  //BTX

  vtkGetObjectMacro(CameraStyle3D, vtkPVInteractorStyle);
  vtkGetObjectMacro(CameraStyle2D, vtkPVInteractorStyle);
  //ETX

  vtkPVSourceCollection *GetSourceList(const char* listname);

  void UpdateSelectMenu();


  void DisableToolbarButtons();
  void EnableToolbarButtons();
  void EnableToolbarButton(const char* buttonName);
  void DisableToolbarButton(const char* buttonName);

  void UpdateSourceMenu();

  void UpdateFilterMenu();
  

  vtkGetObjectMacro(AnimationManager, vtkPVAnimationManager);

  void AddPrototype(const char* name, vtkPVSource* prototype);


  void AddToolbarButton(const char* buttonName, const char* imageName,
                        const char* fileName, const char* command, 
                        const char* balloonHelp, int buttonVisibility);


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


  vtkSetMacro(InDemo, int);
  vtkGetMacro(InDemo, int);


  vtkSetMacro(InComparativeVis, int);
  vtkGetMacro(InComparativeVis, int);


  void AddManipulator(const char* type, const char* name, 
                      vtkPVCameraManipulator*);
  

  void AddManipulatorArgument(const char* type, const char* name, 
                              const char* variable, vtkPVWidget* widget);


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


  int OpenPackage();
  int OpenPackage(const char* fileName);


  virtual void LoadScript() { this->Superclass::LoadScript(); }
  virtual void LoadScript(const char *name);


  void MouseAction(int action,int button, int x,int y, int shift,int control);
  void Configure(int width, int height);
  void KeyAction(char keyCode, int x, int y);


  void SetInteractorStyle(int iStyle);
  int GetInteractorStyle();

  void ChangeInteractorStyle(int index);


  void CenterEntryOpenCallback();
  void CenterEntryCloseCallback();
  void CenterEntryCallback();
  void ResetCenterCallback();
  void ToggleCenterActorCallback();


  vtkGetObjectMacro(CenterXEntry, vtkKWEntry);
  vtkGetObjectMacro(CenterYEntry, vtkKWEntry);
  vtkGetObjectMacro(CenterZEntry, vtkKWEntry);

  virtual void WarningMessage(const char* message);
  
  virtual void ErrorMessage(const char* message);


  vtkPVColorMap* GetPVColorMap(const char* parameterName, 
                               int numberOfComponents);

  vtkPVVolumeAppearanceEditor *GetVolumeAppearanceEditor();
  
  vtkCollection* GetPVColorMaps();


  void SetCenterOfRotation(float f[3]) 
    { this->SetCenterOfRotation(f[0], f[1], f[2]); }
  void SetCenterOfRotation(float x, float y, float z);

  //BTX

  vtkGetObjectMacro(CenterOfRotationStyle, vtkPVInteractorStyleCenterOfRotation);
  //ETX
  

  void EnableNavigationWindow();
  void DisableNavigationWindow();


  virtual void SetInteractiveRenderEnabled(int s);
  vtkBooleanMacro(InteractiveRenderEnabled,int);
  vtkGetMacro(InteractiveRenderEnabled,int);

  void ReadSourceInterfacesFromString(const char*);
  

  vtkLinkedList<vtkPVReaderModule*>* GetReaderList() { return this->ReaderList; }
  //ETX

  virtual vtkKWApplicationSettingsInterface *GetApplicationSettingsInterface();

  //BTX

  void SetInteractor(vtkPVGenericRenderWindowInteractor *iren);
  vtkPVGenericRenderWindowInteractor* GetInteractor() {return this->Interactor;}
  //ETX

  vtkClientServerID GetInteractorID(){ return this->InteractorID;}

  int CheckIfFileIsReadable(const char* fname);


  vtkGetObjectMacro(TranslateCameraButton, vtkKWRadioButton);
  vtkGetObjectMacro(RotateCameraButton, vtkKWRadioButton);
  vtkGetObjectMacro(ResetCameraButton, vtkKWPushButtonWithMenu);
  
  virtual void UpdateToolbarState();


  virtual void UpdateEnableState();
  virtual void UpdateMenuState();
  virtual int GetEnabled();


  void SetProgress(const char* text, int val);
  void StartProgress();
  void EndProgress();


  void SetInteractorEventInformation(int x, int y, int ctrl, int shift,
                                     char keycode, int repeatcount,
                                     const char *keysym);
  void InvokeInteractorEvent(const char *event);

  void AcceptCurrentSource();

  void ToolbarMenuCheckCallback(const char* buttonName);

  void DisplayLookmarkManager();

  vtkGetObjectMacro(PVLookmarkManager, vtkPVLookmarkManager);


  vtkSetMacro(SaveVisibleSourcesOnlyFlag,int);

  void SetToolbarVisibility(const char* identifier, int state);

  virtual void SetSecondaryPanelVisibility(int);

  void AddDefaultAnimation(vtkPVSource* pvSource);

  void UpdateAnimationInterface();


  vtkGetObjectMacro(TraceHelper, vtkPVTraceHelper);

  void ErrorIconCallback();
    
  vtkPVComparativeVisManagerGUI* GetComparativeVisManagerGUI();
  
//BTX
  enum InteractorStyles
  {
    INTERACTOR_STYLE_UNKNOWN = 0,
    INTERACTOR_STYLE_3D = 1,
    INTERACTOR_STYLE_2D = 2,
    INTERACTOR_STYLE_TRACKBALL = 3,
    INTERACTOR_STYLE_CENTER_OF_ROTATION = 4
  };
//ETX


  virtual void ShowMainUserInterface(const char *name)
    { this->Superclass::ShowMainUserInterface(name); }

protected:
  vtkPVWindow();
  ~vtkPVWindow();

  static const char* ComparativeVisMenuLabel;

  int OpenWithReader(const char *fileName, vtkPVReaderModule* reader);
  vtkPVReaderModule* InitializeRead(vtkPVReaderModule* proto, 
                                    const char *fileName);
  virtual void SaveWindowGeometryToRegistry();

  virtual void RestorePVWindowGeometry();

  // Main render window
  vtkPVRenderView *MainView;

  // Should I move this to vtkPVRenderView?
  vtkPVGenericRenderWindowInteractor *Interactor;
  //InteractorID is a duplicate of InteractorID in PVRenderModule.
  //Need to move the logic for InteractorID to PVRenderModule
  vtkClientServerID InteractorID;
  
  // ParaView specific menus
  vtkKWMenu *SourceMenu;
  vtkKWMenu *FilterMenu;
  vtkKWMenu *SelectMenu;
  vtkKWMenu *GlyphMenu;

  vtkPVInteractorStyle *CameraStyle2D;
  vtkPVInteractorStyle *CameraStyle3D;

  // This should be made into a 3D Widget.
  vtkPVInteractorStyleCenterOfRotation *CenterOfRotationStyle;

  // Interactor stuff
  vtkKWToolbar *InteractorToolbar;
  vtkKWPushButtonWithMenu *ResetCameraButton;
  vtkKWRadioButton *RotateCameraButton;
  vtkKWRadioButton *TranslateCameraButton;
    
  // Main toolbar
  vtkKWToolbar* Toolbar;
  // This controls button visibility.
  vtkKWMenuButton* ToolbarMenuButton;
 
  // widgets for setting center of rotation for rotate camera interactor style
  vtkKWToolbar *PickCenterToolbar;
  vtkKWPushButton *PickCenterButton;
  vtkKWPushButton *ResetCenterButton;
  vtkKWPushButton *HideCenterButton;
  vtkKWPushButton *CenterEntryOpenCloseButton;
  vtkKWFrame *CenterEntryFrame;
  vtkKWLabel *CenterXLabel;
  vtkKWEntry *CenterXEntry;
  vtkKWLabel *CenterYLabel;
  vtkKWEntry *CenterYEntry;
  vtkKWLabel *CenterZLabel;
  vtkKWEntry *CenterZEntry;
    
  void ResizeCenterActor();
  
  // Used internally.  Down casts vtkKWApplication to vtkPVApplication
  vtkPVApplication *GetPVApplication();

  // Separating out creation of the main view.
  void CreateMainView(vtkPVApplication *pvApp);
  
  virtual void PrepareForDelete();

  vtkPVSource *CurrentPVSource;

  // The animation interface. I put it in window because
  // if we ever get more that one renderer, the animation
  // will save out the window with all renderers.
  vtkPVAnimationManager* AnimationManager;

  // Initialization methods called from create.
  void InitializeMenus(vtkKWApplication* app);
  void InitializeInteractorInterfaces(vtkKWApplication* app);

  vtkPVTimerLogDisplay *TimerLogDisplay;
  vtkPVErrorLogDisplay *ErrorLogDisplay;

  void CreateComparativeVisManagerGUI();

  // Extensions of files that loaded readers recognize.
  char *FileExtensions;
  char *FileDescriptions;
  // Add a file type and the corresponding prototype
  void AddFileType(const char* description, const char* ext, 
                   vtkPVReaderModule* prototype);

  // Read interface description from XML.
  void ReadSourceInterfaces();
  void ReadSourceInterfacesFromFile(const char*);
  int ReadSourceInterfacesFromDirectory(const char*);

  // Add a file writer.
  void AddFileWriter(vtkPVWriter* writer);  
  
  // Helper for WriteVTKFile() and WritePVTKFile().
  vtkPVWriter* FindPVWriter(const char* fileName, int parallel, int numParts); 

//BTX
  vtkArrayMap<const char*, vtkPVSource*>* Prototypes;
  vtkArrayMap<const char*, vtkPVSourceCollection*>* SourceLists;
  vtkArrayMap<const char*, vtkKWPushButton*>* ToolbarButtons;
  vtkArrayMap<const char*, const char*>* Writers;
  vtkArrayMap<const char*, int>* MenuState;
  vtkLinkedList<vtkPVReaderModule*>* ReaderList;
  vtkLinkedList<const char*>* PackageFiles;
  vtkLinkedList<vtkPVWriter*>* FileWriterList;

  friend class vtkPVXMLPackageParser;
//ETX

  vtkCollection *PVColorMaps;

  vtkPVVolumeAppearanceEditor *VolumeAppearanceEditor;
  
  // This can be used to disable the pop-up dialogs if necessary
  // (usually used from inside regression scripts)
  int UseMessageDialog;

  // Whether or not to read the default interfaces.
  int InitializeDefaultInterfaces;

  const char* ExtractFileExtension(const char* fname);

  void CreateErrorLogDisplay();

  void HideCenterActor();
  void ShowCenterActor();

  int CenterActorVisibility;

  int InteractiveRenderEnabled;

  virtual void UpdateStatusImage();

  // To avoid disabling menus multiple times.
  int MenusDisabled;
  int ToolbarButtonsDisabled;

  int InDemo;
  int InComparativeVis;

  double LastProgress;
  int ExpectProgress;
  int ModifiedEnableState;

  vtkClientServerID ServerFileListingID;

  vtkSMAxesProxy *CenterAxesProxy; 
  char* CenterAxesProxyName;
  vtkSetStringMacro(CenterAxesProxyName);

  vtkPVTraceHelper* TraceHelper;

  int SaveVisibleSourcesOnlyFlag;

  vtkKWToolbar *LookmarkToolbar;
  vtkKWPushButton *LookmarkButton;
  vtkPVLookmarkManager *PVLookmarkManager;

  virtual void ShowMainUserInterface(vtkKWUserInterfacePanel *panel);

private:
  vtkPVComparativeVisManagerGUI* ComparativeVisManagerGUI;

  vtkPVWindow(const vtkPVWindow&); // Not implemented
  void operator=(const vtkPVWindow&); // Not implemented
};


#endif

---