GUI/Widgets/vtkKWParameterValueFunctionEditor.h

Go to the documentation of this file.

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

  Module:    $RCSfile: vtkKWParameterValueFunctionEditor.h,v $

  Copyright (c) Kitware, Inc.
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm 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 __vtkKWParameterValueFunctionEditor_h
#define __vtkKWParameterValueFunctionEditor_h

#include "vtkKWParameterValueFunctionInterface.h"

//BTX
#include "vtkKWHistogram.h" // I need this one
//ETX

class vtkCallbackCommand;
class vtkKWCanvas;
class vtkKWFrame;
class vtkKWIcon;
class vtkKWLabel;
class vtkKWEntryWithLabel;
class vtkKWRange;
class vtkKWMenuButton;

//BTX
class ostrstream;
//ETX

class KWWIDGETS_EXPORT vtkKWParameterValueFunctionEditor : public vtkKWParameterValueFunctionInterface
{
public:
  vtkTypeRevisionMacro(vtkKWParameterValueFunctionEditor,vtkKWParameterValueFunctionInterface);
  void PrintSelf(ostream& os, vtkIndent indent);


  virtual double* GetWholeParameterRange();
  virtual void SetWholeParameterRange(double r0, double r1);
  virtual void GetWholeParameterRange(double &r0, double &r1)
    { r0 = this->GetWholeParameterRange()[0]; 
    r1 = this->GetWholeParameterRange()[1]; }
  virtual void GetWholeParameterRange(double range[2])
    { this->GetWholeParameterRange(range[0], range[1]); };
  virtual void SetWholeParameterRange(double range[2]) 
    { this->SetWholeParameterRange(range[0], range[1]); };

  virtual void SetWholeParameterRangeToFunctionRange();


  virtual double* GetVisibleParameterRange();
  virtual void SetVisibleParameterRange(double r0, double r1);
  virtual void GetVisibleParameterRange(double &r0, double &r1)
    { r0 = this->GetVisibleParameterRange()[0]; 
    r1 = this->GetVisibleParameterRange()[1]; }
  virtual void GetVisibleParameterRange(double range[2])
    { this->GetVisibleParameterRange(range[0], range[1]); };
  virtual void SetVisibleParameterRange(double range[2]) 
    { this->SetVisibleParameterRange(range[0], range[1]); };

  virtual void SetVisibleParameterRangeToWholeParameterRange();


  virtual void SetRelativeVisibleParameterRange(double r0, double r1);
  virtual void GetRelativeVisibleParameterRange(double &r0, double &r1);
  virtual void GetRelativeVisibleParameterRange(double range[2])
    { this->GetRelativeVisibleParameterRange(range[0], range[1]); };
  virtual void SetRelativeVisibleParameterRange(double range[2]) 
    { this->SetRelativeVisibleParameterRange(range[0], range[1]); };


  virtual double* GetWholeValueRange();
  virtual void SetWholeValueRange(double r0, double r1);
  virtual void GetWholeValueRange(double &r0, double &r1)
    { r0 = this->GetWholeValueRange()[0]; 
    r1 = this->GetWholeValueRange()[1]; }
  virtual void GetWholeValueRange(double range[2])
    { this->GetWholeValueRange(range[0], range[1]); };
  virtual void SetWholeValueRange(double range[2]) 
    { this->SetWholeValueRange(range[0], range[1]); };


  virtual double* GetVisibleValueRange();
  virtual void SetVisibleValueRange(double r0, double r1);
  virtual void GetVisibleValueRange(double &r0, double &r1)
    { r0 = this->GetVisibleValueRange()[0]; 
    r1 = this->GetVisibleValueRange()[1]; }
  virtual void GetVisibleValueRange(double range[2])
    { this->GetVisibleValueRange(range[0], range[1]); };
  virtual void SetVisibleValueRange(double range[2]) 
    { this->SetVisibleValueRange(range[0], range[1]); };


  virtual void SetRelativeVisibleValueRange(double r0, double r1);
  virtual void GetRelativeVisibleValueRange(double &r0, double &r1);
  virtual void GetRelativeVisibleValueRange(double range[2])
    { this->GetRelativeVisibleValueRange(range[0], range[1]); };
  virtual void SetRelativeVisibleValueRange(double range[2]) 
    { this->SetRelativeVisibleValueRange(range[0], range[1]); };

  virtual void SetLabelPosition(int);


  vtkBooleanMacro(ParameterRangeVisibility, int);
  virtual void SetParameterRangeVisibility(int);
  vtkGetMacro(ParameterRangeVisibility, int);


  enum 
  {
    ParameterRangePositionTop = 0,
    ParameterRangePositionBottom
  };
  //ETX
  virtual void SetParameterRangePosition(int);
  vtkGetMacro(ParameterRangePosition, int);
  virtual void SetParameterRangePositionToTop()
    { this->SetParameterRangePosition(
      vtkKWParameterValueFunctionEditor::ParameterRangePositionTop); };
  virtual void SetParameterRangePositionToBottom()
    { this->SetParameterRangePosition(
      vtkKWParameterValueFunctionEditor::ParameterRangePositionBottom); };


  vtkBooleanMacro(ValueRangeVisibility, int);
  virtual void SetValueRangeVisibility(int);
  vtkGetMacro(ValueRangeVisibility, int);


  vtkGetObjectMacro(ParameterRange, vtkKWRange);
  vtkGetObjectMacro(ValueRange, vtkKWRange);


  vtkGetVector2Macro(DisplayedWholeParameterRange, double);
  virtual void SetDisplayedWholeParameterRange(double r0, double r1);
  virtual void SetDisplayedWholeParameterRange(double range[2]) 
    { this->SetDisplayedWholeParameterRange(range[0], range[1]); };
  virtual void GetDisplayedVisibleParameterRange(double &r0, double &r1);
  virtual void GetDisplayedVisibleParameterRange(double range[2])
    { this->GetDisplayedVisibleParameterRange(range[0], range[1]); };
  virtual void MapParameterToDisplayedParameter(double p, double *displayed_p);
  virtual void MapDisplayedParameterToParameter(double displayed_p, double *p);
  virtual int GetFunctionPointDisplayedParameter(int id, double *displayed_p);
  

  enum 
  {
    PointPositionValue = 0,
    PointPositionTop,
    PointPositionBottom,
    PointPositionCenter
  };
  //ETX
  virtual void SetPointPositionInValueRange(int);
  vtkGetMacro(PointPositionInValueRange, int);
  virtual void SetPointPositionInValueRangeToValue()
    { this->SetPointPositionInValueRange(
      vtkKWParameterValueFunctionEditor::PointPositionValue); };
  virtual void SetPointPositionInValueRangeToTop()
    { this->SetPointPositionInValueRange(
      vtkKWParameterValueFunctionEditor::PointPositionTop); };
  virtual void SetPointPositionInValueRangeToBottom()
    { this->SetPointPositionInValueRange(
      vtkKWParameterValueFunctionEditor::PointPositionBottom); };
  virtual void SetPointPositionInValueRangeToCenter()
    { this->SetPointPositionInValueRange(
      vtkKWParameterValueFunctionEditor::PointPositionCenter); };


  vtkBooleanMacro(ParameterRangeLabelVisibility, int);
  virtual void SetParameterRangeLabelVisibility(int);
  vtkGetMacro(ParameterRangeLabelVisibility, int);


  vtkBooleanMacro(ValueRangeLabelVisibility, int);
  virtual void SetValueRangeLabelVisibility(int);
  vtkGetMacro(ValueRangeLabelVisibility, int);


  enum
  {
    RangeLabelPositionDefault = 10,
    RangeLabelPositionTop
  };
  //ETX
  virtual void SetRangeLabelPosition(int);
  vtkGetMacro(RangeLabelPosition, int);
  virtual void SetRangeLabelPositionToDefault()
    { this->SetRangeLabelPosition(
      vtkKWParameterValueFunctionEditor::RangeLabelPositionDefault); };
  virtual void SetRangeLabelPositionToTop()
    { this->SetRangeLabelPosition(
      vtkKWParameterValueFunctionEditor::RangeLabelPositionTop); };


  enum
  {
    PointEntriesPositionDefault = 10,
    PointEntriesPositionRight
  };
  //ETX
  virtual void SetPointEntriesPosition(int);
  vtkGetMacro(PointEntriesPosition, int);
  virtual void SetPointEntriesPositionToDefault()
    { this->SetPointEntriesPosition(
      vtkKWParameterValueFunctionEditor::PointEntriesPositionDefault); };
  virtual void SetPointEntriesPositionToRight()
    { this->SetPointEntriesPosition(
      vtkKWParameterValueFunctionEditor::PointEntriesPositionRight); };


  vtkBooleanMacro(PointEntriesVisibility, int);
  virtual void SetPointEntriesVisibility(int);
  vtkGetMacro(PointEntriesVisibility, int);


  vtkBooleanMacro(ParameterEntryVisibility, int);
  virtual void SetParameterEntryVisibility(int);
  vtkGetMacro(ParameterEntryVisibility, int);


  virtual void SetParameterEntryFormat(const char *);
  vtkGetStringMacro(ParameterEntryFormat);

  virtual vtkKWEntryWithLabel* GetParameterEntry();


  vtkBooleanMacro(UserFrameVisibility, int);
  virtual void SetUserFrameVisibility(int);
  vtkGetMacro(UserFrameVisibility, int);


  vtkGetObjectMacro(UserFrame, vtkKWFrame);


  virtual void SetCanvasHeight(int);
  virtual void SetCanvasWidth(int);
  vtkGetMacro(CanvasHeight, int);
  vtkGetMacro(CanvasWidth, int);
  vtkBooleanMacro(ExpandCanvasWidth, int);
  virtual void SetExpandCanvasWidth(int);
  vtkGetMacro(ExpandCanvasWidth, int);
  

  vtkBooleanMacro(CanvasVisibility, int);
  virtual void SetCanvasVisibility(int);
  vtkGetMacro(CanvasVisibility, int);


  vtkBooleanMacro(FunctionLineVisibility, int);
  virtual void SetFunctionLineVisibility(int);
  vtkGetMacro(FunctionLineVisibility, int);


  virtual void SetFunctionLineWidth(int);
  vtkGetMacro(FunctionLineWidth, int);
  

  enum 
  {
    LineStyleSolid = 0,
    LineStyleDash
  };
  //ETX
  virtual void SetFunctionLineStyle(int);
  vtkGetMacro(FunctionLineStyle, int);
  virtual void SetFunctionLineStyleToSolid()
    { this->SetFunctionLineStyle(
      vtkKWParameterValueFunctionEditor::LineStyleSolid); };
  virtual void SetFunctionLineStyleToDash()
    { this->SetFunctionLineStyle(
      vtkKWParameterValueFunctionEditor::LineStyleDash); };


  vtkBooleanMacro(CanvasOutlineVisibility, int);
  virtual void SetCanvasOutlineVisibility(int);
  vtkGetMacro(CanvasOutlineVisibility, int);


  enum 
  {
    CanvasOutlineStyleLeftSide        = 1,
    CanvasOutlineStyleRightSide       = 2,
    CanvasOutlineStyleHorizontalSides = 3,
    CanvasOutlineStyleTopSide         = 4,
    CanvasOutlineStyleBottomSide      = 8,
    CanvasOutlineStyleVerticalSides   = 12,
    CanvasOutlineStyleAllSides        = 15
  };
  //ETX
  vtkBooleanMacro(CanvasOutlineStyle, int);
  virtual void SetCanvasOutlineStyle(int);
  vtkGetMacro(CanvasOutlineStyle, int);
  

  vtkBooleanMacro(CanvasBackgroundVisibility, int);
  virtual void SetCanvasBackgroundVisibility(int);
  vtkGetMacro(CanvasBackgroundVisibility, int);
  

  vtkBooleanMacro(ParameterCursorVisibility, int);
  virtual void SetParameterCursorVisibility(int);
  vtkGetMacro(ParameterCursorVisibility, int);


  virtual void SetParameterCursorPosition(double);
  vtkGetMacro(ParameterCursorPosition, double);
  

  vtkGetVector3Macro(ParameterCursorColor, double);
  virtual void SetParameterCursorColor(double r, double g, double b);
  virtual void SetParameterCursorColor(double rgb[3])
    { this->SetParameterCursorColor(rgb[0], rgb[1], rgb[2]); };


  enum 
  {
    ParameterCursorInteractionStyleNone                     = 0,
    ParameterCursorInteractionStyleDragWithLeftButton       = 1,
    ParameterCursorInteractionStyleSetWithRighButton        = 2,
    ParameterCursorInteractionStyleSetWithControlLeftButton = 4,
    ParameterCursorInteractionStyleAll                      = 7
  };
  //ETX
  vtkBooleanMacro(ParameterCursorInteractionStyle, int);
  virtual void SetParameterCursorInteractionStyle(int);
  vtkGetMacro(ParameterCursorInteractionStyle, int);


  vtkBooleanMacro(ParameterTicksVisibility, int);
  virtual void SetParameterTicksVisibility(int);
  vtkGetMacro(ParameterTicksVisibility, int);


  virtual void SetNumberOfParameterTicks(int);
  vtkGetMacro(NumberOfParameterTicks, int);


  virtual void SetParameterTicksFormat(const char *);
  vtkGetStringMacro(ParameterTicksFormat);


  vtkBooleanMacro(ValueTicksVisibility, int);
  virtual void SetValueTicksVisibility(int);
  vtkGetMacro(ValueTicksVisibility, int);


  virtual void SetNumberOfValueTicks(int);
  vtkGetMacro(NumberOfValueTicks, int);


  virtual void SetValueTicksCanvasWidth(int);
  vtkGetMacro(ValueTicksCanvasWidth, int);


  virtual void SetValueTicksFormat(const char *);
  vtkGetStringMacro(ValueTicksFormat);


  vtkBooleanMacro(ComputeValueTicksFromHistogram, int);
  virtual void SetComputeValueTicksFromHistogram(int);
  vtkGetMacro(ComputeValueTicksFromHistogram, int);


  virtual void SetTicksLength(int);
  vtkGetMacro(TicksLength, int);
  
  virtual void Create(vtkKWApplication *app);


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


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


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


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


  virtual void SetReadOnly(int);
  vtkBooleanMacro(ReadOnly, int);


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


  virtual void SetPointRadius(int);
  vtkGetMacro(PointRadius, int);


  virtual void SetSelectedPointRadius(double);
  vtkGetMacro(SelectedPointRadius, double);


  enum 
  {
    PointStyleDisc = 0,
    PointStyleCursorDown,
    PointStyleCursorUp,
    PointStyleCursorLeft,
    PointStyleCursorRight,
    PointStyleRectangle,
    PointStyleDefault
  };
  //ETX
  virtual void SetPointStyle(int);
  vtkGetMacro(PointStyle, int);
  virtual void SetPointStyleToDisc()
    { this->SetPointStyle(
      vtkKWParameterValueFunctionEditor::PointStyleDisc); };
  virtual void SetPointStyleToCursorDown()
    { this->SetPointStyle(
      vtkKWParameterValueFunctionEditor::PointStyleCursorDown); };
  virtual void SetPointStyleToCursorUp()
    { this->SetPointStyle(
      vtkKWParameterValueFunctionEditor::PointStyleCursorUp); };
  virtual void SetPointStyleToCursorLeft()
    { this->SetPointStyle(
      vtkKWParameterValueFunctionEditor::PointStyleCursorLeft); };
  virtual void SetPointStyleToCursorRight()
    { this->SetPointStyle(
      vtkKWParameterValueFunctionEditor::PointStyleCursorRight); };
  virtual void SetPointStyleToRectangle()
    { this->SetPointStyle(
      vtkKWParameterValueFunctionEditor::PointStyleRectangle); };
  virtual void SetPointStyleToDefault()
    { this->SetPointStyle(
      vtkKWParameterValueFunctionEditor::PointStyleDefault); };
  virtual void SetFirstPointStyle(int);
  vtkGetMacro(FirstPointStyle, int);
  virtual void SetLastPointStyle(int);
  vtkGetMacro(LastPointStyle, int);


  virtual void SetPointOutlineWidth(int);
  vtkGetMacro(PointOutlineWidth, int);


  enum 
  {
    PointMarginNone            = 0,
    PointMarginLeftSide        = 1,
    PointMarginRightSide       = 2,
    PointMarginHorizontalSides = 3,
    PointMarginTopSide         = 4,
    PointMarginBottomSide      = 8,
    PointMarginVerticalSides   = 12,
    PointMarginAllSides        = 15
  };
  //ETX
  vtkBooleanMacro(PointMarginToCanvas, int);
  virtual void SetPointMarginToCanvas(int);
  vtkGetMacro(PointMarginToCanvas, int);


  vtkGetMacro(SelectedPoint, int);
  virtual void SelectPoint(int id);
  virtual void ClearSelection();
  virtual int  HasSelection();
  virtual void SelectNextPoint();
  virtual void SelectPreviousPoint();
  virtual void SelectFirstPoint();
  virtual void SelectLastPoint();


  virtual int RemoveSelectedPoint();
  virtual int RemovePoint(int id);
  virtual int RemovePointAtParameter(double parameter);


  virtual int AddPointAtCanvasCoordinates(int x, int y, int *id);
  virtual int AddPointAtParameter(double parameter, int *id);

  virtual int MergePointsFromEditor(vtkKWParameterValueFunctionEditor *editor);


  vtkGetVector3Macro(FrameBackgroundColor, double);
  virtual void SetFrameBackgroundColor(double r, double g, double b);
  virtual void SetFrameBackgroundColor(double rgb[3])
    { this->SetFrameBackgroundColor(rgb[0], rgb[1], rgb[2]); };
  virtual void SetBackgroundColor(double r, double g, double b);
  virtual void SetBackgroundColor(double rgb[3])
    { this->Superclass::SetBackgroundColor(rgb); };


  vtkGetVector3Macro(PointColor, double);
  virtual void SetPointColor(double r, double g, double b);
  virtual void SetPointColor(double rgb[3])
    { this->SetPointColor(rgb[0], rgb[1], rgb[2]); };
  

  vtkGetVector3Macro(SelectedPointColor, double);
  virtual void SetSelectedPointColor(double r, double g, double b);
  virtual void SetSelectedPointColor(double rgb[3])
    { this->SetSelectedPointColor(rgb[0], rgb[1], rgb[2]); };


  vtkGetVector3Macro(PointTextColor, double);
  virtual void SetPointTextColor(double r, double g, double b);
  virtual void SetPointTextColor(double rgb[3])
    { this->SetPointTextColor(rgb[0], rgb[1], rgb[2]); };


  vtkGetVector3Macro(SelectedPointTextColor, double);
  virtual void SetSelectedPointTextColor(double r, double g, double b);
  virtual void SetSelectedPointTextColor(double rgb[3])
    { this->SetSelectedPointTextColor(rgb[0], rgb[1], rgb[2]); };


  vtkBooleanMacro(ComputePointColorFromValue, int);
  virtual void SetComputePointColorFromValue(int);
  vtkGetMacro(ComputePointColorFromValue, int);
  

  vtkBooleanMacro(PointVisibility, int);
  virtual void SetPointVisibility(int);
  vtkGetMacro(PointVisibility, int);


  vtkBooleanMacro(PointIndexVisibility, int);
  virtual void SetPointIndexVisibility(int);
  vtkGetMacro(PointIndexVisibility, int);


  vtkBooleanMacro(SelectedPointIndexVisibility, int);
  virtual void SetSelectedPointIndexVisibility(int);
  vtkGetMacro(SelectedPointIndexVisibility, int);


  vtkBooleanMacro(PointGuidelineVisibility, int);
  virtual void SetPointGuidelineVisibility(int);
  vtkGetMacro(PointGuidelineVisibility, int);


  virtual void SetPointGuidelineStyle(int);
  vtkGetMacro(PointGuidelineStyle, int);


  vtkGetObjectMacro(Histogram, vtkKWHistogram);
  virtual void SetHistogram(vtkKWHistogram*);
  vtkGetObjectMacro(SecondaryHistogram, vtkKWHistogram);
  virtual void SetSecondaryHistogram(vtkKWHistogram*);


  vtkGetVector3Macro(HistogramColor, double);
  virtual void SetHistogramColor(double r, double g, double b);
  virtual void SetHistogramColor(double rgb[3])
    { this->SetHistogramColor(rgb[0], rgb[1], rgb[2]); };
  vtkGetVector3Macro(SecondaryHistogramColor, double);
  virtual void SetSecondaryHistogramColor(double r, double g, double b);
  virtual void SetSecondaryHistogramColor(double rgb[3])
    { this->SetSecondaryHistogramColor(rgb[0], rgb[1], rgb[2]); };
  

  vtkBooleanMacro(ComputeHistogramColorFromValue, int);
  virtual void SetComputeHistogramColorFromValue(int);
  vtkGetMacro(ComputeHistogramColorFromValue, int);


  virtual void SetHistogramStyle(int);
  vtkGetMacro(HistogramStyle, int);
  virtual void SetSecondaryHistogramStyle(int);
  vtkGetMacro(SecondaryHistogramStyle, int);


  virtual void SetHistogramLogModeOptionMenuVisibility(int);
  vtkBooleanMacro(HistogramLogModeOptionMenuVisibility, int);
  vtkGetMacro(HistogramLogModeOptionMenuVisibility, int);
  virtual void SetHistogramLogModeChangedCommand(
    vtkObject* object,const char *method);
  virtual void InvokeHistogramLogModeChangedCommand();


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


  virtual void SetPointAddedCommand(
    vtkObject* object,const char *method);
  virtual void SetPointChangingCommand(
    vtkObject* object, const char *method);
  virtual void SetPointChangedCommand(
    vtkObject* object, const char *method);
  virtual void SetPointRemovedCommand(
    vtkObject* object, const char *method);
  virtual void SetSelectionChangedCommand(
    vtkObject* object,const char *method);
  virtual void SetFunctionChangedCommand(
    vtkObject* object, const char *method);
  virtual void SetFunctionChangingCommand(
    vtkObject* object, const char *method);
  virtual void SetVisibleRangeChangedCommand(
    vtkObject* object, const char *method);
  virtual void SetVisibleRangeChangingCommand(
    vtkObject* object, const char *method);
  virtual void SetParameterCursorMovingCommand(
    vtkObject* object, const char *method);
  virtual void SetParameterCursorMovedCommand(
    vtkObject* object, const char *method);


  virtual void SetDoubleClickOnPointCommand(
    vtkObject* object,const char *method);


  enum
  {
    FunctionChangedEvent = 10000,
    FunctionChangingEvent,
    PointAddedEvent,
    PointChangedEvent,
    PointChangingEvent,
    PointRemovedEvent,
    SelectionChangedEvent,
    VisibleParameterRangeChangedEvent,
    VisibleParameterRangeChangingEvent,
    VisibleRangeChangedEvent,
    VisibleRangeChangingEvent,
    ParameterCursorMovedEvent,
    ParameterCursorMovingEvent,
    DoubleClickOnPointEvent
  };
  //ETX


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


  virtual int SynchronizeVisibleParameterRange(
    vtkKWParameterValueFunctionEditor *b);
  virtual int DoNotSynchronizeVisibleParameterRange(
    vtkKWParameterValueFunctionEditor *b);


  virtual int SynchronizePoints(vtkKWParameterValueFunctionEditor *b);
  virtual int DoNotSynchronizePoints(vtkKWParameterValueFunctionEditor *b);


  virtual int SynchronizeSingleSelection(
    vtkKWParameterValueFunctionEditor *b);
  virtual int DoNotSynchronizeSingleSelection(
    vtkKWParameterValueFunctionEditor *b);


  virtual int SynchronizeSameSelection(
    vtkKWParameterValueFunctionEditor *b);
  virtual int DoNotSynchronizeSameSelection(
    vtkKWParameterValueFunctionEditor *b);

  virtual void SetBalloonHelpString(const char *str);


  virtual void ConfigureCallback();
  virtual void CanvasEnterCallback();
  virtual void VisibleParameterRangeChangingCallback();
  virtual void VisibleParameterRangeChangedCallback();
  virtual void VisibleValueRangeChangingCallback();
  virtual void VisibleValueRangeChangedCallback();
  virtual void StartInteractionCallback(int x, int y);
  virtual void MovePointCallback(int x, int y, int shift);
  virtual void EndInteractionCallback(int x, int y);
  virtual void ParameterCursorStartInteractionCallback(int x);
  virtual void ParameterCursorEndInteractionCallback();
  virtual void ParameterCursorMoveCallback(int x);
  virtual void ParameterEntryCallback();
  virtual void HistogramLogModeCallback(int mode);
  virtual void DoubleClickOnPointCallback(int x, int y);

  virtual void Update();

  virtual void UpdateEnableState();


  static const char *FunctionTag;
  static const char *SelectedTag;
  static const char *PointTag;
  static const char *PointGuidelineTag;
  static const char *PointTextTag;
  static const char *LineTag;
  static const char *HistogramTag;
  static const char *FrameForegroundTag;
  static const char *FrameBackgroundTag;
  static const char *ParameterCursorTag;
  static const char *ParameterTicksTag;
  static const char *ValueTicksTag;
  //ETX


  virtual int FunctionPointCanBeAdded();
  virtual int FunctionPointCanBeRemoved(int id);
  virtual int FunctionPointParameterIsLocked(int id);
  virtual int FunctionPointValueIsLocked(int id);
  virtual int FunctionPointCanBeMovedToParameter(int id, double parameter);

  virtual int  MoveFunctionPoint(int id,double parameter,const double *values);

protected:
  vtkKWParameterValueFunctionEditor();
  ~vtkKWParameterValueFunctionEditor();

  virtual int FunctionLineIsInVisibleRangeBetweenPoints(int id1, int id2);


  virtual int  GetFunctionPointColorInCanvas(int id, double rgb[3]);
  virtual int  GetFunctionPointTextColorInCanvas(int id, double rgb[3]);
  virtual int  GetFunctionPointCanvasCoordinates(int id, int *x, int *y);
  virtual int  GetFunctionPointCanvasCoordinatesAtParameter(
    double parameter, int *x, int *y);
  virtual int  AddFunctionPointAtCanvasCoordinates(int x, int y, int *id);
  virtual int  AddFunctionPointAtParameter(double parameter, int *id);
  virtual int  MoveFunctionPointToCanvasCoordinates(int id,int x,int y);
  virtual int  MoveFunctionPointToParameter(int id,double parameter,int i=0);
  virtual int  EqualFunctionPointValues(const double *values1, const double *values2);
  virtual int  FindFunctionPointAtCanvasCoordinates(
    int x, int y, int *id, int *c_x, int *c_y);

  virtual void UpdatePointEntries(int id);

  virtual void  RescaleFunctionBetweenEndPoints(int id, double old_parameter);


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


  virtual int MergePointFromEditor(
    vtkKWParameterValueFunctionEditor *editor, int editor_id, int *new_id);


  virtual int CopyPointFromEditor(
    vtkKWParameterValueFunctionEditor *editor, int id);

  int   ParameterRangeVisibility;
  int   ValueRangeVisibility;
  int   PointPositionInValueRange;
  int   ParameterRangePosition;
  int   CanvasHeight;
  int   CanvasWidth;
  int   ExpandCanvasWidth;
  int   LockPointsParameter;
  int   LockEndPointsParameter;
  int   LockPointsValue;
  int   RescaleBetweenEndPoints;
  int   DisableAddAndRemove;
  int   DisableRedraw;
  int   PointRadius;
  double SelectedPointRadius;
  int   FunctionLineWidth;
  int   FunctionLineStyle;
  int   PointGuidelineStyle;
  int   PointOutlineWidth;
  int   PointStyle;
  int   FirstPointStyle;
  int   LastPointStyle;
  int   DisableCommands;
  int   SelectedPoint;
  int   CanvasOutlineVisibility;
  int   CanvasOutlineStyle;
  int   ParameterCursorInteractionStyle;
  int   CanvasBackgroundVisibility;
  int   ParameterCursorVisibility;
  int   FunctionLineVisibility;
  int   CanvasVisibility;
  int   PointVisibility;
  int   PointIndexVisibility;
  int   PointGuidelineVisibility;
  int   SelectedPointIndexVisibility;
  int   ParameterRangeLabelVisibility;
  int   ValueRangeLabelVisibility;
  int   RangeLabelPosition;
  int   PointEntriesPosition;
  int   ParameterEntryVisibility;
  int   PointEntriesVisibility;
  int   UserFrameVisibility;
  int   ParameterTicksVisibility;
  int   ValueTicksVisibility;
  int   ComputeValueTicksFromHistogram;
  int   PointMarginToCanvas;
  int   TicksLength;
  int   NumberOfParameterTicks;
  int   NumberOfValueTicks;
  int   ValueTicksCanvasWidth;
  int   ChangeMouseCursor;
  char* ValueTicksFormat;
  char* ParameterTicksFormat;
  char* ParameterEntryFormat;
  double ParameterCursorPosition;

  double FrameBackgroundColor[3];
  double ParameterCursorColor[3];
  double PointColor[3];
  double SelectedPointColor[3];
  double PointTextColor[3];
  double SelectedPointTextColor[3];
  int    ComputePointColorFromValue;
  int    InUserInteraction;

  // Commands

  char  *PointAddedCommand;
  char  *PointChangingCommand;
  char  *PointChangedCommand;
  char  *PointRemovedCommand;
  char  *SelectionChangedCommand;
  char  *FunctionChangedCommand;
  char  *FunctionChangingCommand;
  char  *VisibleRangeChangedCommand;
  char  *VisibleRangeChangingCommand;
  char  *ParameterCursorMovingCommand;
  char  *ParameterCursorMovedCommand;
  char  *DoubleClickOnPointCommand;

  virtual void InvokeCommand(const char *command);
  virtual void InvokePointCommand(
    const char *command, int id, const char *extra = 0);

  virtual void InvokePointAddedCommand(int id);
  virtual void InvokePointChangingCommand(int id);
  virtual void InvokePointChangedCommand(int id);
  virtual void InvokePointRemovedCommand(int id, double parameter);
  virtual void InvokeSelectionChangedCommand();
  virtual void InvokeFunctionChangedCommand();
  virtual void InvokeFunctionChangingCommand();
  virtual void InvokeVisibleRangeChangedCommand();
  virtual void InvokeVisibleRangeChangingCommand();
  virtual void InvokeParameterCursorMovingCommand();
  virtual void InvokeParameterCursorMovedCommand();
  virtual void InvokeDoubleClickOnPointCommand(int id);

  // GUI

  vtkKWCanvas         *Canvas;
  vtkKWRange          *ParameterRange;
  vtkKWRange          *ValueRange;
  vtkKWFrame          *TopLeftContainer;
  vtkKWFrame          *TopLeftFrame;
  vtkKWFrame          *UserFrame;
  vtkKWFrame          *PointEntriesFrame;
  vtkKWLabel          *RangeLabel;
  vtkKWEntryWithLabel *ParameterEntry;
  vtkKWCanvas         *ValueTicksCanvas;
  vtkKWCanvas         *ParameterTicksCanvas;
  vtkKWCanvas         *GuidelineValueCanvas;

  // Histogram

  vtkKWHistogram    *Histogram;
  vtkKWHistogram    *SecondaryHistogram;
  //BTX
  vtkKWHistogram::ImageDescriptor *HistogramImageDescriptor;
  vtkKWHistogram::ImageDescriptor *SecondaryHistogramImageDescriptor;
  //ETX
  double        HistogramColor[3];
  double        SecondaryHistogramColor[3];
  int           ComputeHistogramColorFromValue;
  int           HistogramStyle;
  int           SecondaryHistogramStyle;
  unsigned long LastHistogramBuildTime;
  int           HistogramLogModeOptionMenuVisibility;
  char          *HistogramLogModeChangedCommand;

  vtkKWMenuButton  *HistogramLogModeOptionMenu;
  virtual void CreateHistogramLogModeOptionMenu(vtkKWApplication *app);
  virtual void UpdateHistogramLogModeOptionMenu();


  virtual void Bind();
  virtual void UnBind();


  virtual void CreateLabel(vtkKWApplication *app);
  virtual void CreateParameterRange(vtkKWApplication *app);
  virtual void CreateValueRange(vtkKWApplication *app);
  virtual void CreateRangeLabel(vtkKWApplication *app);
  virtual void CreatePointEntriesFrame(vtkKWApplication *app);
  virtual void CreateParameterEntry(vtkKWApplication *app);
  virtual void CreateTopLeftContainer(vtkKWApplication *app);
  virtual void CreateTopLeftFrame(vtkKWApplication *app);
  virtual void CreateUserFrame(vtkKWApplication *app);
  virtual void CreateValueTicksCanvas(vtkKWApplication *app);
  virtual void CreateParameterTicksCanvas(vtkKWApplication *app);
  virtual void CreateGuidelineValueCanvas(vtkKWApplication *app);
  virtual int IsTopLeftFrameUsed();
  virtual int IsPointEntriesFrameUsed();
  virtual int IsGuidelineValueCanvasUsed();


  virtual void Pack();
  virtual void PackPointEntries();

  virtual void GetCanvasItemCenter(int item_id, int *x, int *y);


  virtual void GetCanvasScalingFactors(double factors[2]);
  virtual void GetCanvasMargin(
    int *margin_left, int *margin_right, int *margin_top, int *margin_bottom);
  virtual void GetCanvasScrollRegion(double *x, double *y, double *x2, double *y2);
  virtual void GetCanvasHorizontalSlidingBounds(
    double p_v_range_ext[2], int bounds[2], int margins[2]);


  virtual unsigned long GetRedrawFunctionTime();
  virtual void Redraw();
  virtual void RedrawSizeDependentElements();
  virtual void RedrawPanOnlyDependentElements();
  virtual void RedrawFunctionDependentElements();
  virtual void RedrawSinglePointDependentElements(int id);


  virtual void RedrawFunction();
  virtual void RedrawPoint(int id, ostrstream *tk_cmd = 0);
  virtual void RedrawLine(int id1, int id2, ostrstream *tk_cmd = 0);
  virtual void GetLineCoordinates(int id1, int id2, ostrstream *tk_cmd);
  //ETX

  virtual void RedrawRangeFrame();

  virtual void RedrawRangeTicks();

  virtual void RedrawParameterCursor();


  virtual void RedrawHistogram();
  //BTX 
  virtual void UpdateHistogramImageDescriptor(vtkKWHistogram::ImageDescriptor*);
  //ETX

  //BTX
  // Simple class designed to hold previous ranges and optimize
  // the way the editor is refreshed

  class Ranges
  {
  public:
    double WholeParameterRange[2];
    double VisibleParameterRange[2];
    double WholeValueRange[2];
    double VisibleValueRange[2];

    Ranges();
    void GetRangesFrom(vtkKWParameterValueFunctionEditor *);
    int HasSameWholeRangesComparedTo(Ranges*);
    int NeedResizeComparedTo(Ranges*);
    int NeedPanOnlyComparedTo(Ranges*);
  };
  Ranges        LastRanges;
  unsigned long LastRedrawFunctionTime;
  //ETX

  double DisplayedWholeParameterRange[2];

  //BTX
  enum
  {
    ConstrainedMoveFree,
    ConstrainedMoveHorizontal,
    ConstrainedMoveVertical
  };
  //ETX
  int           LastSelectionCanvasCoordinateX;
  int           LastSelectionCanvasCoordinateY;
  int           LastConstrainedMove;

  virtual void UpdateRangeLabel();

  virtual void UpdateParameterEntry(int id);


  virtual int CanvasHasTag(
    const char *tag, int *suffix = 0, vtkKWCanvas *canv = NULL);


  virtual void CanvasRemoveTag(const char *tag, const char *canv_name = NULL);
  virtual void CanvasRemoveTag(
    const char *prefix, int id, const char *canv_name = NULL);

  virtual int CanvasCheckTagType(const char *prefix, int id, const char *type);

  // Synchronization callbacks

  vtkCallbackCommand *SynchronizeCallbackCommand;
  vtkCallbackCommand *SynchronizeCallbackCommand2;

  virtual int AddObserversList(int nb_events, int *events, vtkCommand *cmd);
  virtual int RemoveObserversList(int nb_events, int *events, vtkCommand *cmd);

  virtual void ProcessSynchronizationEvents(
    vtkObject *caller, unsigned long event, void *calldata);
  static void ProcessSynchronizationEventsFunction(
    vtkObject *object, unsigned long event, void *clientdata, void *calldata);

  virtual void ProcessSynchronizationEvents2(
    vtkObject *caller, unsigned long event, void *calldata);
  static void ProcessSynchronizationEventsFunction2(
    vtkObject *object, unsigned long event, void *clientdata, void *calldata);

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

#endif

---