Classes | Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes

QmitkDataStorageTreeModel Class Reference

#include <QmitkDataStorageTreeModel.h>

Collaboration diagram for QmitkDataStorageTreeModel:
Collaboration graph
[legend]

List of all members.

Classes

class  TreeItem

Public Member Functions

 QmitkDataStorageTreeModel (mitk::DataStorage *_DataStorage, bool _PlaceNewNodesOnTop=false, QObject *parent=0)
 ~QmitkDataStorageTreeModel ()
mitk::DataNode::Pointer GetNode (const QModelIndex &index) const
virtual std::vector
< mitk::DataNode * > 		GetNodeSet () const
const mitk::DataStorage::Pointer GetDataStorage () const
void SetPlaceNewNodesOnTop (bool _PlaceNewNodesOnTop)
Qt::ItemFlags flags (const QModelIndex &index) const
QVariant data (const QModelIndex &index, int role=Qt::DisplayRole) const
QVariant headerData (int section, Qt::Orientation orientation, int role=Qt::DisplayRole) const
int rowCount (const QModelIndex &parent=QModelIndex()) const
int columnCount (const QModelIndex &parent=QModelIndex()) const
QModelIndex index (int row, int column, const QModelIndex &parent=QModelIndex()) const
QModelIndex parent (const QModelIndex &index) const
bool setData (const QModelIndex &index, const QVariant &value, int role=Qt::EditRole)
bool setHeaderData (int section, Qt::Orientation orientation, const QVariant &value, int role=Qt::EditRole)
bool dropMimeData (const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
Qt::DropActions supportedDropActions () const
QMimeData * mimeData (const QModelIndexList &indexes) const
void SetDataStorage (mitk::DataStorage *_DataStorage)
void SetDataStorageDeleted (const itk::Object *_DataStorage)
virtual void AddNode (const mitk::DataNode *node)
virtual void RemoveNode (const mitk::DataNode *node)
virtual void SetNodeModified (const mitk::DataNode *node)
QModelIndex GetIndex (const mitk::DataNode *) const

Static Public Attributes

static const std::string COLUMN_NAME
static const std::string COLUMN_TYPE
static const std::string COLUMN_VISIBILITY

Protected Member Functions

void AdjustLayerProperty ()
TreeItem * TreeItemFromIndex (const QModelIndex &index) const
QModelIndex IndexFromTreeItem (TreeItem *) const
mitk::DataNode * GetParentNode (const mitk::DataNode *node) const
void TreeToVector (TreeItem *parent, std::vector< TreeItem * > &vec) const
void TreeToNodeSet (TreeItem *parent, std::vector< mitk::DataNode * > &vec) const

Protected Attributes

mitk::WeakPointer
< mitk::DataStorage > 		m_DataStorage
mitk::NodePredicateBase::Pointer m_Predicate
bool m_PlaceNewNodesOnTop
TreeItem * m_Root

Detailed Description

Definition at line 35 of file QmitkDataStorageTreeModel.h.

Constructor & Destructor Documentation

QmitkDataStorageTreeModel::QmitkDataStorageTreeModel ( mitk::DataStorage *  _DataStorage,
bool  _PlaceNewNodesOnTop = false,
QObject *  parent = 0 
)

Definition at line 35 of file QmitkDataStorageTreeModel.cpp.

References m_Predicate, mitk::NodePredicateAnd::New(), mitk::BoolProperty::New(), mitk::NodePredicateProperty::New(), mitk::NodePredicateNot::New(), mitk::NodePredicateData::New(), and SetDataStorage().

: QAbstractItemModel(parent)
, m_DataStorage(0)
, m_PlaceNewNodesOnTop(_PlaceNewNodesOnTop)
, m_Root(0)
{
  mitk::NodePredicateData::Pointer dataIsNull = mitk::NodePredicateData::New(0);
  mitk::NodePredicateNot::Pointer dataIsNotNull
    = mitk::NodePredicateNot::New(dataIsNull);// Show only nodes that really contain dat

  mitk::NodePredicateProperty::Pointer isHelperObject = mitk::NodePredicateProperty::New("helper object"
    , mitk::BoolProperty::New(true));

  mitk::NodePredicateNot::Pointer isNotHelperObject
    = mitk::NodePredicateNot::New(isHelperObject);// Show only nodes that really contain dat

  mitk::NodePredicateAnd::Pointer dataIsNotNullAndIsNotHelperObject = mitk::NodePredicateAnd::New(dataIsNotNull,
    isNotHelperObject);

  m_Predicate = dataIsNotNullAndIsNotHelperObject;

  this->SetDataStorage(_DataStorage);
}
QmitkDataStorageTreeModel::~QmitkDataStorageTreeModel (  )

Definition at line 61 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::Delete(), m_Root, and SetDataStorage().

{
  // set data storage to 0 = remove all listeners
  this->SetDataStorage(0);
  m_Root->Delete(); m_Root = 0;
}

Member Function Documentation

void QmitkDataStorageTreeModel::AddNode ( const mitk::DataNode *  node ) [virtual]

Adds a node to this model. If a predicate is set (not null) the node will be checked against it.The node has to have a data object (no one wants to see empty nodes).

Definition at line 308 of file QmitkDataStorageTreeModel.cpp.

References AdjustLayerProperty(), QmitkDataStorageTreeModel::TreeItem::Find(), QmitkDataStorageTreeModel::TreeItem::GetChildCount(), QmitkDataStorageTreeModel::TreeItem::GetIndex(), GetParentNode(), index(), QmitkDataStorageTreeModel::TreeItem::InsertChild(), mitk::WeakPointer< TObjectType >::IsNull(), m_DataStorage, m_PlaceNewNodesOnTop, m_Predicate, and m_Root.

Referenced by SetDataStorage().

{
  if(node == 0
    || m_DataStorage.IsNull()
    || !m_DataStorage->Exists(node)
    || !m_Predicate->CheckNode(node)
    || m_Root->Find(node) != 0)
    return;

  // find out if we have a root node
  TreeItem* parentTreeItem = m_Root;
  QModelIndex index;
  mitk::DataNode* parentDataNode = this->GetParentNode(node);

  if(parentDataNode) // no top level data node
  {
    parentTreeItem = m_Root->Find(parentDataNode); // find the corresponding tree item
    if(!parentTreeItem)
    {
      this->AddNode(parentDataNode);
      parentTreeItem = m_Root->Find(parentDataNode);
      if(!parentTreeItem)
        return;
    }

    // get the index of this parent with the help of the grand parent
    index = this->createIndex(parentTreeItem->GetIndex(), 0, parentTreeItem);
  }

  // add node
  if(m_PlaceNewNodesOnTop)
  {
    // emit beginInsertRows event
    beginInsertRows(index, 0, 0);
    parentTreeItem->InsertChild(new TreeItem(
        const_cast<mitk::DataNode*>(node)), 0);
  }
  else
  {
    beginInsertRows(index, parentTreeItem->GetChildCount()
                    , parentTreeItem->GetChildCount());
    new TreeItem(const_cast<mitk::DataNode*>(node), parentTreeItem);
  }

  // emit endInsertRows event
  endInsertRows();

  this->AdjustLayerProperty();
}
void QmitkDataStorageTreeModel::AdjustLayerProperty (  ) [protected]

Adjusts the LayerProperty according to the nodes position

transform the tree into an array and set the layer property descending

Definition at line 461 of file QmitkDataStorageTreeModel.cpp.

References mitk::RenderingManager::GetInstance(), m_Root, and TreeToVector().

Referenced by AddNode(), dropMimeData(), and RemoveNode().

{
  std::vector<TreeItem*> vec;
  this->TreeToVector(m_Root, vec);

  int i = vec.size()-1;
  for(std::vector<TreeItem*>::const_iterator it = vec.begin(); it != vec.end(); ++it)
  {
    (*it)->GetDataNode()->SetIntProperty("layer", i);
    --i;
  }
  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
int QmitkDataStorageTreeModel::columnCount ( const QModelIndex &  parent = QModelIndex() ) const

Definition at line 112 of file QmitkDataStorageTreeModel.cpp.

{
  return 1;
}
QVariant QmitkDataStorageTreeModel::data ( const QModelIndex &  index,
int  role = Qt::DisplayRole 
) const

Definition at line 200 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::GetDataNode(), QmitkNodeDescriptorManager::GetDescriptor(), QmitkNodeDescriptor::GetIcon(), QmitkNodeDescriptorManager::GetInstance(), mitk::DataNode::GetName(), mitk::DataNode::IsVisible(), QmitkDataNodeRole, and TreeItemFromIndex().

{
  mitk::DataNode* dataNode = this->TreeItemFromIndex(index)->GetDataNode();

  // get name of treeItem (may also be edited)
  QString nodeName = QString::fromStdString(dataNode->GetName());
  if(nodeName.isEmpty())
    nodeName = "unnamed";

  if (role == Qt::DisplayRole)
    return nodeName;
  else if(role == Qt::ToolTipRole)
    return nodeName;
  else if(role == Qt::DecorationRole)
  {
    QmitkNodeDescriptor* nodeDescriptor
      = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(dataNode);
    return nodeDescriptor->GetIcon();
  }
  else if(role == Qt::CheckStateRole)
  {
    return dataNode->IsVisible(0);
  }
  else if(role == QmitkDataNodeRole)
  {
    return QVariant::fromValue<mitk::DataNode::Pointer>(mitk::DataNode::Pointer(dataNode));
  }

  return QVariant();
}
bool QmitkDataStorageTreeModel::dropMimeData ( const QMimeData *  data,
Qt::DropAction  action,
int  row,
int  column,
const QModelIndex &  parent 
)

Definition at line 143 of file QmitkDataStorageTreeModel.cpp.

References AdjustLayerProperty(), QmitkDataStorageTreeModel::TreeItem::GetChildCount(), QmitkDataStorageTreeModel::TreeItem::GetIndex(), QmitkDataStorageTreeModel::TreeItem::GetParent(), index(), IndexFromTreeItem(), QmitkDataStorageTreeModel::TreeItem::IndexOfChild(), QmitkDataStorageTreeModel::TreeItem::InsertChild(), m_Root, QmitkDataStorageTreeModel::TreeItem::RemoveChild(), and TreeItemFromIndex().

{
  if (action == Qt::IgnoreAction)
    return true;

  if(data->hasFormat("application/x-qabstractitemmodeldatalist"))
  {
    QString arg = QString(data->data("application/x-qabstractitemmodeldatalist").data());
    long val = arg.toLong();
    TreeItem* draggedItem = static_cast<TreeItem *>((void*)val);
    TreeItem* dropItem = this->TreeItemFromIndex(parent);
    TreeItem* parentItem = dropItem->GetParent();
    if(dropItem == m_Root) // item was dropped onto empty space
      parentItem = m_Root;

    if(draggedItem != dropItem && draggedItem->GetParent() == parentItem) // dragging is only allowed within the same parent
    {
      QModelIndex parentModelIndex = this->IndexFromTreeItem(parentItem);

      // remove dragged item
      this->beginRemoveRows(parentModelIndex, draggedItem->GetIndex(), draggedItem->GetIndex());

      parentItem->RemoveChild(draggedItem);

      endRemoveRows();

      // now insert it again at the drop item position
      int index = parentItem->IndexOfChild(dropItem);
      if(dropItem == m_Root)
        index = parentItem->GetChildCount();

      beginInsertRows(parentModelIndex, index, index);

      // add node
      parentItem->InsertChild( draggedItem, index );

      // emit endInsertRows event
      endInsertRows();

      this->AdjustLayerProperty();
    }
  }
  return false;
}
Qt::ItemFlags QmitkDataStorageTreeModel::flags ( const QModelIndex &  index ) const

Definition at line 103 of file QmitkDataStorageTreeModel.cpp.

{
  if (index.isValid())
    return Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable
      | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
  else
    return Qt::ItemIsDropEnabled;
}
const mitk::DataStorage::Pointer QmitkDataStorageTreeModel::GetDataStorage (  ) const

Get the DataStorage.

Definition at line 73 of file QmitkDataStorageTreeModel.cpp.

References mitk::WeakPointer< TObjectType >::GetPointer(), and m_DataStorage.

{
  return m_DataStorage.GetPointer();
}
QModelIndex QmitkDataStorageTreeModel::GetIndex ( const mitk::DataNode *  node ) const
Returns:
an index for the given datatreenode in the tree. If the node is not found

Definition at line 515 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::Find(), IndexFromTreeItem(), and m_Root.

Referenced by QmitkDataManagerView::SelectionChanged().

{
  if(m_Root)
  {
    TreeItem* item = m_Root->Find(node);
    if(item)
      return this->IndexFromTreeItem(item);
  }
  return QModelIndex();
}
mitk::DataNode::Pointer QmitkDataStorageTreeModel::GetNode ( const QModelIndex &  index ) const

Get node at a specific model index. This function is used to get a node from a QModelIndex

Definition at line 68 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::GetDataNode(), and TreeItemFromIndex().

Referenced by QmitkDataManagerView::ColorActionChanged(), QmitkDataManagerView::ColorChanged(), QmitkDataManagerView::GetSelectedNodes(), QmitkDataManagerView::NodeTableViewContextMenuRequested(), QmitkDataManagerView::OpacityActionChanged(), QmitkDataManagerView::OpacityChanged(), QmitkDataManagerView::RemoveSelectedNodes(), QmitkDataManagerView::SaveSelectedNodes(), QmitkDataManagerView::SurfaceRepresentationActionToggled(), QmitkDataManagerView::SurfaceRepresentationMenuAboutToShow(), QmitkDataManagerView::TextureInterpolationChanged(), and QmitkDataManagerView::TextureInterpolationToggled().

{
  return this->TreeItemFromIndex(index)->GetDataNode();
}
std::vector< mitk::DataNode * > QmitkDataStorageTreeModel::GetNodeSet (  ) const [virtual]

Returns a copy of the node-vector that is shown by this model

Definition at line 495 of file QmitkDataStorageTreeModel.cpp.

References m_Root, and TreeToNodeSet().

Referenced by QmitkDataManagerView::MakeAllNodesInvisible(), QmitkDataManagerView::NodeSelectionChanged(), and QmitkDataManagerView::ShowOnlySelectedNodes().

{
  std::vector<mitk::DataNode*> vec;
  if(m_Root)
    this->TreeToNodeSet(m_Root, vec);

  return vec;
}
mitk::DataNode * QmitkDataStorageTreeModel::GetParentNode ( const mitk::DataNode *  node ) const [protected]

Returns the first element in the nodes sources list (if available) or 0

Definition at line 418 of file QmitkDataStorageTreeModel.cpp.

References m_DataStorage.

Referenced by AddNode().

{
  mitk::DataNode* dataNode = 0;

  mitk::DataStorage::SetOfObjects::ConstPointer _Sources = m_DataStorage->GetSources(node);

  if(_Sources->Size() > 0)
    dataNode = _Sources->front();

  return dataNode;
}
QVariant QmitkDataStorageTreeModel::headerData ( int  section,
Qt::Orientation  orientation,
int  role = Qt::DisplayRole 
) const

Definition at line 231 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::GetDataNode(), and m_Root.

{
   if (orientation == Qt::Horizontal && role == Qt::DisplayRole && m_Root)
     return QString::fromStdString(m_Root->GetDataNode()->GetName());

   return QVariant();
}
QModelIndex QmitkDataStorageTreeModel::index ( int  row,
int  column,
const QModelIndex &  parent = QModelIndex() 
) const

called whenever the model or the view needs to create a QModelIndex for a particular child item (or a top-level item if parent is an invalid QModelIndex)

Definition at line 78 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::GetChild(), and m_Root.

Referenced by AddNode(), dropMimeData(), and SetNodeModified().

{
  TreeItem* parentItem;

  if (!parent.isValid())
    parentItem = m_Root;
  else
    parentItem = static_cast<TreeItem*>(parent.internalPointer());

  TreeItem *childItem = parentItem->GetChild(row);
  if (childItem)
    return createIndex(row, column, childItem);
  else
    return QModelIndex();


}
QModelIndex QmitkDataStorageTreeModel::IndexFromTreeItem ( TreeItem *  item ) const [protected]

Gives a ModelIndex for the Tree Item

Definition at line 487 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::GetIndex(), and m_Root.

Referenced by dropMimeData(), GetIndex(), and RemoveNode().

{
  if(item == m_Root)
    return QModelIndex();
  else
    return this->createIndex(item->GetIndex(), 0, item);
}
QMimeData * QmitkDataStorageTreeModel::mimeData ( const QModelIndexList &  indexes ) const

Definition at line 190 of file QmitkDataStorageTreeModel.cpp.

                                                                                    {
  QMimeData * ret = new QMimeData;
  long a = reinterpret_cast<long>(indexes.at(0).internalPointer());

  QString result;
  QTextStream(&result) << a;
  ret->setData("application/x-qabstractitemmodeldatalist", QByteArray(result.toAscii()));
  return ret;
}
QModelIndex QmitkDataStorageTreeModel::parent ( const QModelIndex &  index ) const

Definition at line 117 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::GetIndex(), QmitkDataStorageTreeModel::TreeItem::GetParent(), m_Root, and TreeItemFromIndex().

{
  if (!index.isValid())
    return QModelIndex();

  TreeItem *childItem = this->TreeItemFromIndex(index);
  TreeItem *parentItem = childItem->GetParent();

  if (parentItem == m_Root)
    return QModelIndex();

  return this->createIndex(parentItem->GetIndex(), 0, parentItem);
}
void QmitkDataStorageTreeModel::RemoveNode ( const mitk::DataNode *  node ) [virtual]

Removes a node from this model. Also removes any event listener from the node.

Definition at line 364 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::AddChild(), AdjustLayerProperty(), QmitkDataStorageTreeModel::TreeItem::Find(), QmitkDataStorageTreeModel::TreeItem::GetChildCount(), QmitkDataStorageTreeModel::TreeItem::GetChildren(), QmitkDataStorageTreeModel::TreeItem::GetIndex(), QmitkDataStorageTreeModel::TreeItem::GetParent(), IndexFromTreeItem(), and m_Root.

Referenced by SetDataStorage().

{
  if(!m_Root) return;

  TreeItem* treeItem = m_Root->Find(node);
  if(!treeItem)
    return; // return because there is no treeitem containing this node

  TreeItem* parentTreeItem = treeItem->GetParent();
  QModelIndex parentIndex = this->IndexFromTreeItem(parentTreeItem);

  // emit beginRemoveRows event (QModelIndex is empty because we dont have a tree model)
  this->beginRemoveRows(parentIndex, treeItem->GetIndex(), treeItem->GetIndex());

  // remove node
  std::vector<TreeItem*> children = treeItem->GetChildren();
  delete treeItem;

  // emit endRemoveRows event
  endRemoveRows();

  // move all children of deleted node into its parent
  for ( std::vector<TreeItem*>::iterator it = children.begin()
    ; it != children.end(); it++)
  {
    // emit beginInsertRows event
    beginInsertRows(parentIndex, parentTreeItem->GetChildCount(), parentTreeItem->GetChildCount());

    // add nodes again
    parentTreeItem->AddChild(*it);

    // emit endInsertRows event
    endInsertRows();
  }

  this->AdjustLayerProperty();
}
int QmitkDataStorageTreeModel::rowCount ( const QModelIndex &  parent = QModelIndex() ) const

Definition at line 96 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::GetChildCount(), and TreeItemFromIndex().

{
  TreeItem *parentTreeItem = this->TreeItemFromIndex(parent);
  return parentTreeItem->GetChildCount();
}
bool QmitkDataStorageTreeModel::setData ( const QModelIndex &  index,
const QVariant &  value,
int  role = Qt::EditRole 
)

Definition at line 430 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::GetDataNode(), mitk::RenderingManager::GetInstance(), mitk::DataNode::SetStringProperty(), mitk::DataNode::SetVisibility(), and TreeItemFromIndex().

{
  mitk::DataNode* dataNode = this->TreeItemFromIndex(index)->GetDataNode();
  if(!dataNode)
    return false;

  if(role == Qt::EditRole && !value.toString().isEmpty())
  {
    dataNode->SetStringProperty("name", value.toString().toStdString().c_str());
  }
  else if(role == Qt::CheckStateRole)
  {
    // Please note: value.toInt() returns 2, independentely from the actual checkstate of the index element.
  // Therefore the checkstate is being estimated again here.

  QVariant qcheckstate = index.data(Qt::CheckStateRole);
  int checkstate = qcheckstate.toInt();
    bool isVisible = bool(checkstate);
  dataNode->SetVisibility(!isVisible);
    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
  }
  // inform listeners about changes
  emit dataChanged(index, index);
  return true;
}
void QmitkDataStorageTreeModel::SetDataStorage ( mitk::DataStorage *  _DataStorage )

Sets the DataStorage. The whole model will be resetted.

Definition at line 241 of file QmitkDataStorageTreeModel.cpp.

References AddNode(), QmitkDataStorageTreeModel::TreeItem::Delete(), mitk::WeakPointer< TObjectType >::IsNotNull(), m_DataStorage, m_Predicate, m_Root, mitk::DataNode::New(), mitk::WeakPointer< TObjectType >::ObjectDelete, RemoveNode(), SetDataStorageDeleted(), and SetNodeModified().

Referenced by QmitkDataStorageTreeModel(), SetDataStorageDeleted(), and ~QmitkDataStorageTreeModel().

{
  if(m_DataStorage != _DataStorage) // dont take the same again
  {
    if(m_DataStorage.IsNotNull())
    {
      // remove Listener for the data storage itself
      m_DataStorage.ObjectDelete.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
        , const itk::Object*>( this, &QmitkDataStorageTreeModel::SetDataStorageDeleted ) );

      // remove listeners for the nodes
      m_DataStorage->AddNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
        , const mitk::DataNode*>( this, &QmitkDataStorageTreeModel::AddNode ) );

      m_DataStorage->ChangedNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
        , const mitk::DataNode*>( this, &QmitkDataStorageTreeModel::SetNodeModified ) );

      m_DataStorage->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
        , const mitk::DataNode*>( this, &QmitkDataStorageTreeModel::RemoveNode ) );

    }

    // take over the new data storage
    m_DataStorage = _DataStorage;

    // delete the old root (if necessary, create new)
    if(m_Root)
      m_Root->Delete();
    mitk::DataNode::Pointer rootDataNode = mitk::DataNode::New();
    rootDataNode->SetName("Data Manager");
    m_Root = new TreeItem(rootDataNode, 0);
    this->reset();

    if(m_DataStorage.IsNotNull())
    {
      // add Listener for the data storage itself
      m_DataStorage.ObjectDelete.AddListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
        , const itk::Object*>( this, &QmitkDataStorageTreeModel::SetDataStorageDeleted ) );

      // add listeners for the nodes
      m_DataStorage->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
        , const mitk::DataNode*>( this, &QmitkDataStorageTreeModel::AddNode ) );

      m_DataStorage->ChangedNodeEvent.AddListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
        , const mitk::DataNode*>( this, &QmitkDataStorageTreeModel::SetNodeModified ) );

      m_DataStorage->RemoveNodeEvent.AddListener( mitk::MessageDelegate1<QmitkDataStorageTreeModel
        , const mitk::DataNode*>( this, &QmitkDataStorageTreeModel::RemoveNode ) );

      mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = m_DataStorage->GetSubset(m_Predicate);

      // finally add all nodes to the model
      for(mitk::DataStorage::SetOfObjects::const_iterator it=_NodeSet->begin(); it!=_NodeSet->end()
        ; it++)
      {
        // save node
        this->AddNode(*it);
      }
    }
  }
}
void QmitkDataStorageTreeModel::SetDataStorageDeleted ( const itk::Object *  _DataStorage )

Notify that the DataStorage was deleted. The whole model will be resetted.

Definition at line 303 of file QmitkDataStorageTreeModel.cpp.

References SetDataStorage().

Referenced by SetDataStorage().

{
  this->SetDataStorage(0);
}
bool QmitkDataStorageTreeModel::setHeaderData ( int  section,
Qt::Orientation  orientation,
const QVariant &  value,
int  role = Qt::EditRole 
)

Definition at line 456 of file QmitkDataStorageTreeModel.cpp.

{
  return false;
}
void QmitkDataStorageTreeModel::SetNodeModified ( const mitk::DataNode *  node ) [virtual]

Sets a node to modfified. Called by the DataStorage

Definition at line 402 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::Find(), QmitkDataStorageTreeModel::TreeItem::GetIndex(), QmitkDataStorageTreeModel::TreeItem::GetParent(), index(), and m_Root.

Referenced by SetDataStorage().

{
  TreeItem* treeItem = m_Root->Find(node);
  if(!treeItem)
    return;

  TreeItem* parentTreeItem = treeItem->GetParent();
  // as the root node should not be removed one should always have a parent item
  if(!parentTreeItem)
    return;
  QModelIndex index = this->createIndex(treeItem->GetIndex(), 0, treeItem);

  // now emit the dataChanged signal
  emit dataChanged(index, index);
}
void QmitkDataStorageTreeModel::SetPlaceNewNodesOnTop ( bool  _PlaceNewNodesOnTop )

Definition at line 359 of file QmitkDataStorageTreeModel.cpp.

References m_PlaceNewNodesOnTop.

Referenced by QmitkDataManagerView::CreateQtPartControl(), and QmitkDataManagerView::OnPreferencesChanged().

{
  m_PlaceNewNodesOnTop = _PlaceNewNodesOnTop;
}
Qt::DropActions QmitkDataStorageTreeModel::supportedDropActions (  ) const

Definition at line 138 of file QmitkDataStorageTreeModel.cpp.

{
  return Qt::CopyAction | Qt::MoveAction;
}
QmitkDataStorageTreeModel::TreeItem * QmitkDataStorageTreeModel::TreeItemFromIndex ( const QModelIndex &  index ) const [protected]

invoked after m_DataStorage or m_Predicate changed

Definition at line 131 of file QmitkDataStorageTreeModel.cpp.

References m_Root.

Referenced by data(), dropMimeData(), GetNode(), parent(), rowCount(), and setData().

{
  if (index.isValid())
    return static_cast<TreeItem *>(index.internalPointer());
  else
    return m_Root;
}
void QmitkDataStorageTreeModel::TreeToNodeSet ( TreeItem *  parent,
std::vector< mitk::DataNode * > &  vec 
) const [protected]

Adds all Childs in parent to vec. Before a child is added the function is called recursively

Definition at line 504 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::GetChild(), QmitkDataStorageTreeModel::TreeItem::GetChildCount(), and QmitkDataStorageTreeModel::TreeItem::GetDataNode().

Referenced by GetNodeSet().

{
  TreeItem* current;
  for(int i = 0; i<parent->GetChildCount(); ++i)
  {
    current = parent->GetChild(i);
    vec.push_back(current->GetDataNode());
    this->TreeToNodeSet(current, vec);
  }
}
void QmitkDataStorageTreeModel::TreeToVector ( TreeItem *  parent,
std::vector< TreeItem * > &  vec 
) const [protected]

Adds all Childs in parent to vec. Before a child is added the function is called recursively

Definition at line 476 of file QmitkDataStorageTreeModel.cpp.

References QmitkDataStorageTreeModel::TreeItem::GetChild(), and QmitkDataStorageTreeModel::TreeItem::GetChildCount().

Referenced by AdjustLayerProperty().

{
  TreeItem* current;
  for(int i = 0; i<parent->GetChildCount(); ++i)
  {
    current = parent->GetChild(i);
    this->TreeToVector(current, vec);
    vec.push_back(current);
  }
}

Member Data Documentation

const std::string QmitkDataStorageTreeModel::COLUMN_NAME [static]

Definition at line 39 of file QmitkDataStorageTreeModel.h.

const std::string QmitkDataStorageTreeModel::COLUMN_TYPE [static]

Definition at line 40 of file QmitkDataStorageTreeModel.h.

const std::string QmitkDataStorageTreeModel::COLUMN_VISIBILITY [static]

Definition at line 41 of file QmitkDataStorageTreeModel.h.

mitk::WeakPointer<mitk::DataStorage> QmitkDataStorageTreeModel::m_DataStorage [protected]

Definition at line 222 of file QmitkDataStorageTreeModel.h.

Referenced by AddNode(), GetDataStorage(), GetParentNode(), and SetDataStorage().

bool QmitkDataStorageTreeModel::m_PlaceNewNodesOnTop [protected]

Definition at line 224 of file QmitkDataStorageTreeModel.h.

Referenced by AddNode(), and SetPlaceNewNodesOnTop().

mitk::NodePredicateBase::Pointer QmitkDataStorageTreeModel::m_Predicate [protected]

Definition at line 223 of file QmitkDataStorageTreeModel.h.

Referenced by AddNode(), QmitkDataStorageTreeModel(), and SetDataStorage().

TreeItem* QmitkDataStorageTreeModel::m_Root [protected]

Definition at line 225 of file QmitkDataStorageTreeModel.h.

Referenced by AddNode(), AdjustLayerProperty(), dropMimeData(), GetIndex(), GetNodeSet(), headerData(), index(), IndexFromTreeItem(), parent(), RemoveNode(), SetDataStorage(), SetNodeModified(), TreeItemFromIndex(), and ~QmitkDataStorageTreeModel().

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines
Generated on Tue Oct 19 2010 16:19:50 for mitk by  doxygen 1.7.2