GUI/Client/vtkPVSimpleAnimationCue.h

Go to the documentation of this file.

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

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

#include "vtkPVTracedWidget.h"
class vtkPVSimpleAnimationCueObserver;
class vtkCollectionIterator;
class vtkCollection;
class vtkSMAnimationCueProxy;
class vtkSMKeyFrameAnimationCueManipulatorProxy;
class vtkPVKeyFrame;
class vtkSMProxy;
class vtkSMProperty;
class vtkSMPropertyStatusManager;

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

  virtual void Create(vtkKWApplication* app);


  vtkGetMacro(Virtual, int);

  virtual char* GetTextRepresentation();


  void SetParentAnimationCue(vtkPVSimpleAnimationCue* cue)
    { this->ParentCue = cue; }


  vtkSetStringMacro(LabelText);
  vtkGetStringMacro(LabelText);

  unsigned long GetKeyFramesMTime();

  int GetNumberOfKeyFrames();

  double GetKeyFrameTime(int id);

  void SetKeyFrameTime(int id, double time);

  int AddNewKeyFrame(double time);

  virtual int CreateAndAddKeyFrame(double time, int type);

  int AppendNewKeyFrame();
 
  virtual void RemoveAllKeyFrames();

  void RemoveKeyFrame(vtkPVKeyFrame* keyframe);

  int RemoveKeyFrame(int id);

  void DeleteKeyFrame(int id);

  int CanDeleteKeyFrame(int index);

  int CanDeleteSelectedKeyFrame();

  vtkPVKeyFrame* GetKeyFrame(int id);

  vtkPVKeyFrame* GetKeyFrame(const char* name);

  vtkPVKeyFrame* GetSelectedKeyFrame();

  virtual void ReplaceKeyFrame(vtkPVKeyFrame* oldFrame, vtkPVKeyFrame* newFrame);

  virtual int IsKeyFrameTypeSupported(int type);
  

  virtual void SetAnimatedProxy(vtkSMProxy* proxy);
  vtkSMProxy* GetAnimatedProxy();
  virtual void SetAnimatedPropertyName(const char* name);
  const char* GetAnimatedPropertyName();
  void SetAnimatedDomainName(const char* name);
  const char* GetAnimatedDomainName();
  void SetAnimatedElement(int index);
  int GetAnimatedElement();

  virtual void StartRecording();

  virtual void StopRecording();

  virtual void RecordState(double ntime, double offset);


  vtkGetObjectMacro(CueProxy, vtkSMAnimationCueProxy);

  void SetCueProxy(vtkSMAnimationCueProxy* cueProxy);

  void InitializeKeyFrameUsingCurrentState(vtkPVKeyFrame* keyframe);

  virtual void UpdateEnableState();

  virtual void SelectKeyFrame(int id);


  vtkGetMacro(SelectedKeyFrameIndex, int);
//BTX
  // Event saying that the Keyframes managed by this cue have changed.
  // In non-virtual mode, this is triggered when the KeyFrameManipulatorProxy
  // is modified. In Virtual mode, since there is no KeyFrameManipulatorProxy,
  // this class itself triggers this event when it modifies the end time points.
  enum {
    KeysModifiedEvent = 3001,
    SelectionChangedEvent
  };
//ETX


  virtual void SetTimeBounds(double bounds[2], int enable_scaling=0);
  virtual int GetTimeBounds(double* bounds);


  void SetKeyFrameParent(vtkKWWidget* kfParent);
  vtkGetObjectMacro(KeyFrameParent, vtkKWWidget);


  void SetDuration(double duration);
  vtkGetMacro(Duration, double);



  vtkGetMacro(DefaultKeyFrameType, int);
  vtkSetMacro(DefaultKeyFrameType, int);

  //BTX

  enum {
    RAMP = 0,
    STEP,
    EXPONENTIAL,
    SINUSOID,
    CAMERA,
    LAST_NOT_USED
  };
  //ETX

  vtkPVKeyFrame* ReplaceKeyFrame(int type, vtkPVKeyFrame* replaceFrame = NULL);

  vtkPVKeyFrame* NewKeyFrame(int type);


  int GetKeyFrameType(vtkPVKeyFrame* kf);
  int GetKeyFrameType(vtkSMProxy* kf);

protected:
  vtkPVSimpleAnimationCue();
  ~vtkPVSimpleAnimationCue();

  virtual void SelectKeyFrameInternal(int id);
  virtual void CreateProxy();

  void CleanupKeyFramesGUI();

  void InitializeGUIFromProxy();


  vtkPVKeyFrame* CreateNewKeyFrameAndInit(int type);


  vtkSetMacro(Virtual, int);

  int AddKeyFrame(vtkPVKeyFrame* keyframe);


  vtkKWWidget* KeyFrameParent;
  vtkCollection* PVKeyFrames;
  vtkCollectionIterator* PVKeyFramesIterator;

  vtkSMPropertyStatusManager* PropertyStatusManager;
  vtkPVSimpleAnimationCue* ParentCue;

  int Virtual;
  int NumberOfPoints;
  double PointParameters[2];
  vtkSMAnimationCueProxy* CueProxy;
  char* CueProxyName;
  vtkSetStringMacro(CueProxyName);

  vtkSMKeyFrameAnimationCueManipulatorProxy* KeyFrameManipulatorProxy;
  void SetKeyFrameManipulatorProxy(vtkSMKeyFrameAnimationCueManipulatorProxy*);

  void SetupManipulatorProxy();
  
  char* KeyFrameManipulatorProxyName;
  vtkSetStringMacro(KeyFrameManipulatorProxyName);
  char* KeyFrameManipulatorProxyXMLName;
  vtkSetStringMacro(KeyFrameManipulatorProxyXMLName);

  char* LabelText;
  int ProxiesRegistered;

  int InRecording;
  int SelectedKeyFrameIndex;

  int PreviousStepKeyFrameAdded;

  int KeyFramesCreatedCount;

  int DefaultKeyFrameType;


  virtual void RegisterProxies();
  virtual void UnregisterProxies(); 
//BTX
  friend class vtkPVSimpleAnimationCueObserver;
  vtkPVSimpleAnimationCueObserver* Observer;
  void Observe(vtkObject* toObserver, unsigned long event);
  virtual void ExecuteEvent(vtkObject* wdg, unsigned long event, void*data);
//ETX

  double Duration;

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


#endif

---