dox/Filtering/vtkKWEObjectTreeNodeIterator.h

Go to the documentation of this file.

//=============================================================================
//   This file is part of VTKEdge. See vtkedge.org for more information.
//
//   Copyright (c) 2010 Kitware, Inc.
//
//   VTKEdge may be used under the terms of the BSD License
//   Please see the file Copyright.txt in the root directory of
//   VTKEdge for further information.
//
//   Alternatively, you may see: 
//
//   http://www.vtkedge.org/vtkedge/project/license.html
//
//
//   For custom extensions, consulting services, or training for
//   this or any other Kitware supported open source project, please
//   contact Kitware at sales@kitware.com.
//
//
//=============================================================================
#ifndef __vtkKWEObjectTreeNodeIterator_h
#define __vtkKWEObjectTreeNodeIterator_h

#include "vtkObject.h"
#include "vtkSmartPointer.h"
#include "VTKEdgeConfigure.h" // include configuration header

#include <vtkstd/vector>

class vtkKWEObjectTreeNodeBase;
class vtkKWEObjectTreeNodeIteratorInternals;

class VTKEdge_FILTERING_EXPORT vtkKWEObjectTreeNodeIterator : public vtkObject
{
public:
  static vtkKWEObjectTreeNodeIterator* New();
  vtkTypeRevisionMacro(vtkKWEObjectTreeNodeIterator, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);


  void SetBaseNode(vtkKWEObjectTreeNodeBase* baseNode);
  vtkGetObjectMacro(BaseNode, vtkKWEObjectTreeNodeBase);


  void SetPatternNode(vtkKWEObjectTreeNodeBase* patternNode);
  vtkGetObjectMacro(PatternNode, vtkKWEObjectTreeNodeBase);

  void InitTraversal() { this->GoToFirstNode(); };

  void GoToFirstNode();

  void GoToNextNode();

  vtkKWEObjectTreeNodeBase *GetCurrentNode();


  vtkGetMacro(CurrentDepth, int);

  bool IsDoneWithTraversal();


  vtkBooleanMacro(IncludeBaseNode, bool);
  vtkSetMacro(IncludeBaseNode, bool);
  vtkGetMacro(IncludeBaseNode, bool);


  vtkSetClampMacro(MaximumTraversalDepth, int, 0, VTK_LARGE_INTEGER);
  vtkGetMacro(MaximumTraversalDepth, int);


  void SetTraversalToChildrenOnly()
    {
    this->SetMaximumTraversalDepth(1);
    this->IncludeBaseNodeOff();
    }


  void SetTraversalToEntireSubtree()
    {
    this->SetMaximumTraversalDepth(VTK_LARGE_INTEGER);
    this->IncludeBaseNodeOn();
    }

  enum TraversalModes
    {
    DEPTH_FIRST = 0,
    BREADTH_FIRST
    };


  void SetTraversalModeToDepthFirst()
    { this->SetTraversalMode( DEPTH_FIRST ); }
  void SetTraversalModeToBreadthFirst()
    { this->SetTraversalMode( BREADTH_FIRST ); }
  vtkSetClampMacro(TraversalMode, int, DEPTH_FIRST, BREADTH_FIRST);
  vtkGetMacro(TraversalMode, int);
  const char *GetTraversalModeAsString();


  vtkBooleanMacro(ConsiderInheritedProperties, bool);
  vtkSetMacro(ConsiderInheritedProperties, bool);
  vtkGetMacro(ConsiderInheritedProperties, bool);

protected:
  vtkKWEObjectTreeNodeIterator();
  virtual ~vtkKWEObjectTreeNodeIterator();

  vtkKWEObjectTreeNodeBase *BaseNode;
  vtkKWEObjectTreeNodeBase *PatternNode;

  vtkSmartPointer<vtkKWEObjectTreeNodeBase> CurrentNode;

  vtkKWEObjectTreeNodeIteratorInternals *Internals;

  bool IncludeBaseNode;

  unsigned long InitTraversalTime;

  friend class vtkKWEObjectTreeNodeBase;
  void AddChildren(vtkstd::vector<vtkKWEObjectTreeNodeBase*> &children);

  int CurrentDepth;

  int MaximumTraversalDepth;

  int TraversalMode;

  bool ConsiderInheritedProperties;

  // internal method for clearing the stack
  void Clear();

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

#endif