vtkSlicerNodeSelectorWidget.h

Go to the documentation of this file.

/*=auto=========================================================================

  Portions (c) Copyright 2005 Brigham and Women's Hospital (BWH) All Rights Reserved.

  See Doc/copyright/copyright.txt
  or http://www.slicer.org/copyright/copyright.txt for details.

  Program:   3D Slicer
  Module:    $RCSfile: vtkSlicerNodeSelectorWidget.h,v $
  Date:      $Date: 2010-06-11 16:45:05 -0400 (Fri, 11 Jun 2010) $
  Version:   $Revision: 13771 $

=========================================================================auto=*/

//


#ifndef __vtkSlicerNodeSelectorWidget_h
#define __vtkSlicerNodeSelectorWidget_h

#include "vtkCallbackCommand.h"

#include "vtkKWMenuButtonWithSpinButtonsWithLabel.h"
#include "vtkKWMenuButtonWithSpinButtons.h"
#include "vtkKWMenuButton.h"

#include "vtkMRMLScene.h"
#include "vtkMRMLNode.h"

#include "vtkSlicerBaseGUI.h"
#include "vtkSlicerContextMenuHelper.h"

class vtkSlicerColorLUTIcons;
class VTK_SLICER_BASE_GUI_EXPORT vtkSlicerNodeSelectorWidget : public vtkKWMenuButtonWithSpinButtonsWithLabel
{
public:
  static vtkSlicerNodeSelectorWidget* New();
  vtkTypeRevisionMacro(vtkSlicerNodeSelectorWidget,vtkKWMenuButtonWithSpinButtonsWithLabel);
  void PrintSelf(ostream& os, vtkIndent indent);

  vtkGetObjectMacro(MRMLScene, vtkMRMLScene);
  void SetMRMLScene(vtkMRMLScene *MRMLScene);

  void SetNodeClass(const char *className, const char *attName, const char* attValue, const char *nodeName);

  void AddNodeClass(const char *className, const char *attName, const char* attValue, const char *nodeName);

  const char* GetNodeClass(int ind) {
    return NodeClasses[ind].c_str();
  };

  const char* GetNodeName(int ind) {
    return NodeNames[ind].c_str();
  };

  const char* GetNodeAttributeName(int ind) {
    return AttributeNames[ind]==std::string("") ? NULL : AttributeNames[ind].c_str();
  };

  const char* GetNodeAttributeValue(int ind) {
    return AttributeValues[ind]==std::string("") ? NULL : AttributeValues[ind].c_str();
  };

  int GetNumberOfNodeClasses() {
    return (int)NodeClasses.size();
  };

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

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

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

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

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

  void AddExcludedChildClass(const char *className)
    {
    this->ExcludedChildClasses.push_back(className);
    };

  int GetNumberOfExcludedChildClasses()
    {
      return (int)this->ExcludedChildClasses.size();
    };

  const char* GetExcludedChildClass(int index)
    {
    return this->ExcludedChildClasses[index].c_str();
    };


  vtkMRMLNode *GetSelected();

  void SetSelected(vtkMRMLNode *node);

  void SetSelectedNew(const char *className);

//BTX
  enum
    {
      NodeSelectedEvent = 11000,
      NewNodeEvent = 11001,
      NodeRenameEvent = 11002,
      NodeAddedEvent = 11003
    };
//ETX

  void UpdateMenu();
  void UnconditionalUpdateMenu();

  vtkSetObjectMacro(ContextMenuHelper, vtkSlicerContextMenuHelper);
  vtkGetObjectMacro(ContextMenuHelper, vtkSlicerContextMenuHelper);

  void ClearMenu();

  void ProcessNewNodeCommand(const char *className, const char *nodeName);
  void ProcessCommand(char *selectedID);

  bool CheckNodeClass(vtkMRMLNode *node);
  bool HasNodeClass(const char  *className);

  void AddColorIcons();

  vtkGetMacro(InMRMLCallbackFlag, int);
  void SetInMRMLCallbackFlag (int flag) {
    this->InMRMLCallbackFlag = flag;
  }

protected:
  vtkSlicerNodeSelectorWidget();
  virtual ~vtkSlicerNodeSelectorWidget();



  virtual void CreateWidget();

//BTX
  std::vector<std::string> NodeClasses;
  std::vector<std::string> AttributeNames;
  std::vector<std::string> AttributeValues;
  std::vector<std::string> NodeNames;
  std::vector<std::string> ExcludedChildClasses;

  std::map<std::string, std::string> NodeID_to_EntryName;
  std::string MakeEntryName(vtkMRMLNode *node);
  std::string FindEntryName(vtkMRMLNode *node);

  std::string SelectedID;
//ETX

  int NewNodeEnabled;

  int NoneEnabled;

  int DefaultEnabled;

  int ShowHidden;

  int ChildClassesEnabled;

  vtkMRMLScene       *MRMLScene;
  vtkSlicerContextMenuHelper      *ContextMenuHelper;

private:

  int NewNodeCount;

  vtkCallbackCommand *MRMLCallbackCommand;

  int InMRMLCallbackFlag;

  virtual bool CheckAdditionalConditions(vtkMRMLNode* vtkNotUsed(node) ){return true;}

  virtual int AddAditionalNodes(){return 0;}

  virtual vtkMRMLNode* GetSelectedInAdditional(){return NULL;}

  vtkSlicerColorLUTIcons *ColorIcons;
       
  vtkSlicerNodeSelectorWidget(const vtkSlicerNodeSelectorWidget&); 
  void operator=(const vtkSlicerNodeSelectorWidget&); 
};

#endif