GUI/Client/vtkPVColorMap.h

Go to the documentation of this file.

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

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


#include "vtkPVTracedWidget.h"
#include "vtkClientServerID.h" // Needed for LookupTableID

class vtkKWChangeColorButton;
class vtkKWCheckButton;
class vtkKWEntry;
class vtkKWLabel;
class vtkKWFrame;
class vtkKWFrameWithLabel;
class vtkKWMenuButton;
class vtkKWMenuButton;
class vtkKWPushButton;
class vtkKWScaleWithEntry;
class vtkPVTextPropertyEditor;
class vtkPVApplication;
class vtkPVDataSetAttributesInformation;
class vtkPVRenderView;
class vtkPVColorMapObserver;
class vtkPVSource;
class vtkKWRange;
class vtkTextProperty;
class vtkSMScalarBarWidgetProxy;
class vtkSMLookupTableProxy;
class vtkSMProxy;

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

  virtual void Create(vtkKWApplication *app);

  vtkPVApplication *GetPVApplication();
  

  void SetPVRenderView(vtkPVRenderView *view);
  vtkPVRenderView* GetPVRenderView() { return this->PVRenderView;}


  void SetScalarBarTitle(const char* Name);
  void SetScalarBarTitleNoTrace(const char* name);
  vtkGetStringMacro(ScalarBarTitle);


  void SetArrayName(const char* name);
  const char* GetArrayName();
  int MatchArrayName(const char* name, int numberOfComponents);

  void SetNumberOfVectorComponents(int num);
  int GetNumberOfVectorComponents();



  void SetScalarBarLabelFormat(const char* Name);
  const char* GetScalarBarLabelFormat();

  void CreateParallelTclObjects(vtkPVApplication *pvApp);
                

  void ResetScalarRange();
  void ResetScalarRangeInternal();
  void ResetScalarRangeInternal(vtkPVSource* source);
  

  void SetScalarBarVisibility(int val);
  int GetScalarBarVisibility() { return this->ScalarBarVisibility;}  


  void SetScalarBarPosition1(float x, float y);
  void SetScalarBarPosition2(float x, float y);
  void SetScalarBarOrientation(int);
  

  void SetColorSchemeToRedBlue();
  void SetColorSchemeToBlueRed();
  void SetColorSchemeToGrayscale();
  void SetColorSchemeToLabBlueRed();


  void SetVectorComponent(int component);
  vtkGetMacro(VectorComponent,int);

  void SaveInBatchScript(ofstream *file);

  // --- UI Stuff ---


  void ScalarBarCheckCallback();
  void ScalarRangeWidgetCallback();
  void LockCheckCallback();

  void SetScalarRangeLock(int val);

  void BackButtonCallback();

  void ScalarBarTitleEntryCallback();


  void ScalarBarVectorTitleEntryCallback();
  void SetScalarBarVectorTitle(const char* name);

  void ScalarBarLabelFormatEntryCallback();


  void StartColorButtonCallback(double r, double g, double b);
  void EndColorButtonCallback(double r, double g, double b);
  void SetStartHSV(double h, double s, double v);
  void SetEndHSV(double h, double s, double v);

  void MapConfigureCallback(int width, int height);


  void NumberOfColorsScaleCallback();
  void SetNumberOfColors(int num);


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


  virtual void ExecuteEvent(vtkObject* wdg, unsigned long event,  
                            void* calldata);
//ETX


  vtkGetObjectMacro(ScalarBarCheck, vtkKWCheckButton);
  vtkGetObjectMacro(TitleTextPropertyWidget, vtkPVTextPropertyEditor);
  vtkGetObjectMacro(LabelTextPropertyWidget, vtkPVTextPropertyEditor);

  // Call backs from the vector mode frame.
  void VectorModeMagnitudeCallback();
  void VectorModeComponentCallback();
  void VectorComponentCallback(int component);


  void IncrementUseCount();
  void DecrementUseCount();

  void SaveState(ofstream *file);

  virtual void RenderView();

  void UpdateForSource(vtkPVSource* source);


  void SetWholeScalarRange(double min, double max);
  vtkGetVector2Macro(WholeScalarRange,double);


  void SetScalarRange(double min, double max);
  void SetScalarRangeInternal(double min, double max);
  vtkGetVector2Macro(ScalarRange,double);

  virtual void UpdateEnableState();

  void TitleTextPropertyWidgetCallback();


  virtual void SetTitleColor(double r, double g, double b);
  virtual void SetTitleOpacity(double opacity);
  virtual void SetTitleFontFamily(int font);
  virtual void SetTitleBold(int bold);
  virtual void SetTitleItalic(int italic);
  virtual void SetTitleShadow(int shadow); 
  
  void LabelTextPropertyWidgetCallback();


  virtual void SetLabelColor(double r, double g, double b);
  virtual void SetLabelOpacity(double opacity);
  virtual void SetLabelFontFamily(int font);
  virtual void SetLabelBold(int bold);
  virtual void SetLabelItalic(int italic);
  virtual void SetLabelShadow(int shadow); 

  vtkSMProxy* GetProxyByName(const char* name);

protected:
  vtkPVColorMap();
  ~vtkPVColorMap();

  vtkPVColorMapObserver* ScalarBarObserver;

  void InitializeObservers();
  void UpdateVectorComponentMenu();
  // Visibility depends on check and UseCount.
  void UpdateInternalScalarBarVisibility();
  void ComputeScalarRangeForSource(vtkPVSource* pvs, double* range);

  vtkPVRenderView *PVRenderView;

  int Initialized;
  int ScalarBarVisibility;
  int InternalScalarBarVisibility;
  int UserModifiedScalarRange;

  // Keep local ivars to avoid depending on widget values.
  double ScalarRange[2];
  // WholeScalarRange contain the maximums of the scalarRange widget.
  double WholeScalarRange[2];
  int ScalarRangeLock;
  
  // User interaface.
  vtkKWFrameWithLabel* ColorMapFrame;
  vtkKWLabel*        ArrayNameLabel;
  // Stuff for setting the range of the color map.
  vtkKWFrame*       ScalarRangeFrame;
  vtkKWCheckButton*  ScalarRangeLockCheck;
  vtkKWRange*        ScalarRangeWidget;
  vtkKWScaleWithEntry* NumberOfColorsScale;
  // Stuff for selecting start and end colors.
  vtkKWFrame*            ColorEditorFrame;
  vtkKWChangeColorButton* StartColorButton;
  vtkKWLabel*        Map;
  vtkKWChangeColorButton* EndColorButton;

  vtkKWFrameWithLabel* VectorFrame;
  vtkKWMenuButton*   VectorModeMenu;
  vtkKWMenuButton*   VectorComponentMenu;
  vtkKWEntry*        ScalarBarVectorTitleEntry;

  vtkKWFrameWithLabel* ScalarBarFrame;
  vtkKWCheckButton*  ScalarBarCheck;
  vtkKWFrame*        ScalarBarTitleFrame;
  vtkKWLabel*        ScalarBarTitleLabel;
  vtkKWEntry*        ScalarBarTitleEntry;
  vtkKWFrame*        ScalarBarLabelFormatFrame;
  vtkKWLabel*        ScalarBarLabelFormatLabel;
  vtkKWEntry*        ScalarBarLabelFormatEntry;
  
  vtkPVTextPropertyEditor *TitleTextPropertyWidget;
  vtkPVTextPropertyEditor *LabelTextPropertyWidget;
  
  // For the map image.
  unsigned char *MapData;
  int MapDataSize;
  int MapWidth;
  int MapHeight;
  void UpdateMap(int width, int height);
  void UpdateMap();

  vtkKWMenuButton* PresetsMenuButton;  
  vtkKWPushButton*   BackButton;

  vtkSMScalarBarWidgetProxy *ScalarBarProxy;
  char *ScalarBarProxyName;
  vtkSetStringMacro(ScalarBarProxyName);

  vtkSMLookupTableProxy* LookupTableProxy;
  char* LookupTableProxyName;
  vtkSetStringMacro(LookupTableProxyName);

  // TextProperty dummies for the label and title property
  vtkTextProperty* LabelTextProperty;
  vtkTextProperty* TitleTextProperty;

  // For creating a proper title for the scalar bar.
  char *ScalarBarTitle;
  char *ScalarBarVectorTitle;
  char *VectorMagnitudeTitle;
  char **VectorComponentTitles;
  int NumberOfVectorComponents;
  int VectorComponent;
  void UpdateScalarBarTitle();
  char* ArrayName; 


  void SetTitleColorInternal(double r, double g, double b);
 
  void SetTitleOpacityInternal(double opacity);

  void SetTitleFontFamilyInternal(int font);

  void SetTitleBoldInternal(int bold);

  void SetTitleItalicInternal(int italic);

  void SetTitleShadowInternal(int shadow);

  void SetLabelColorInternal(double r, double g, double b);
 
  void SetLabelOpacityInternal(double opacity);

  void SetLabelFontFamilyInternal(int font);

  void SetLabelBoldInternal(int bold);

  void SetLabelItalicInternal(int italic);

  void SetLabelShadowInternal(int shadow);

  void SetTitleInternal(const char* name);
  

  int GetVectorModeInternal();
  void SetVectorModeInternal(int mode);


  const char* GetLabelFormatInternal();
  void SetLabelFormatInternal(const char* format);


  const char* GetArrayNameInternal();
  void SetArrayNameInternal(const char* name);


  void GetHueRangeInternal(double range[2]);
  void GetSaturationRangeInternal(double range[2]);
  void GetValueRangeInternal(double range[2]);
  void SetHSVRangesInternal(double hrange[2],
    double srange[2], double vrange[2]);
  //void SetSaturationRangeInternal(double range[2]);
  //void SetValueRangeInternal(double range[2]);
 

  void SetNumberOfColorsInternal(int num);
  int GetNumberOfColorsInternal();
  

  void GetLabelTextPropertyInternal();
  void GetTitleTextPropertyInternal();
  
  void SetVisibilityInternal(int visible);
  void SetVectorComponentInternal(int component);


  void SetPosition1Internal(double x, double y);
  void GetPosition1Internal(double pos[2]);
  

  void SetPosition2Internal(double x, double y);
  void GetPosition2Internal(double pos[2]);
 

  void SetOrientationInternal(int orientation);
  int GetOrientationInternal();

  // Leaving this name for this function for the timebeing
  // till we can move the code from SetScalarRangeInternal
  // somewhere. All ...Internal methods push values onto 
  // proxies.
  void SetScalarBarWidgetScalarRangeInternal(double min, double max);
  
  // For Saving into a tcl script.
  int VisitedFlag;

  // For determining how many data objects are using the color map.
  //  This is used to make the scalar bar invisible when not used.
  int UseCount;

  void ComputeScalarRange(
    vtkPVDataSetAttributesInformation* attrInfo, double* range);

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

#endif

---