ModuleBase_ITreeNode.h

// Copyright (C) 2014-2023  CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
#ifndef ModuleBase_ITreeNode_H
#define ModuleBase_ITreeNode_H
 
#include "ModuleBase.h"
#include "ModuleBase_Definitions.h"
 
#include <ModelAPI_Object.h>
#include <ModelAPI_Document.h>
 
#include <QList>
#include <QString>
#include <QIcon>
#include <QVariant>
 
#ifdef _MSC_VER
#pragma warning(disable: 4100)
#endif
 
class ModuleBase_ITreeNode;
class ModuleBase_IWorkshop;
 
typedef QList<ModuleBase_ITreeNode*> QTreeNodesList;
 
class ModuleBase_ITreeNode
{
public:
  enum VisibilityState {
    NoneState,
    Visible,
    SemiVisible,
    Hidden
  };
 
  ModuleBase_ITreeNode(ModuleBase_ITreeNode* theParent = 0) : myParent(theParent) {}
 
  virtual ~ModuleBase_ITreeNode() { deleteChildren(); }
 
  virtual std::string type() const = 0;
 
  virtual QVariant data(int theColumn, int theRole) const { return QVariant(); }
 
  virtual Qt::ItemFlags flags(int theColumn) const {
    return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
  }
 
  ModuleBase_ITreeNode* parent() const { return myParent; }
 
  QTreeNodesList children() const { return myChildren; }
 
  ModuleBase_ITreeNode* subNode(int theRow) const
  {
    if ((theRow > -1) && (theRow < myChildren.length()))
      return myChildren.at(theRow);
    return 0;
  }
 
  ModuleBase_ITreeNode* subNode(const ObjectPtr& theObj, bool allLevels = true) const
  {
    foreach(ModuleBase_ITreeNode* aNode, myChildren) {
      if (aNode->object() == theObj)
        return aNode;
      if (allLevels) {
        ModuleBase_ITreeNode* aSubNode = aNode->subNode(theObj, allLevels);
        if (aSubNode)
          return aSubNode;
      }
    }
    return 0;
  }
 
  bool hasSubNode(ModuleBase_ITreeNode* theNode, bool allLevels = true) const
  {
    foreach(ModuleBase_ITreeNode* aNode, myChildren) {
      if (aNode == theNode)
        return true;
      if (allLevels) {
        if (aNode->hasSubNode(theNode))
          return true;
      }
    }
    return false;
  }
 
  int childrenCount() const { return myChildren.length(); }
 
  int nodeRow(ModuleBase_ITreeNode* theNode) const { return myChildren.indexOf(theNode); }
 
  virtual ObjectPtr object() const { return ObjectPtr(); }
 
  virtual void update() {}
 
  virtual QTreeNodesList objectCreated(const QObjectPtrList& theObjects) {
    return QTreeNodesList();
  }
 
  virtual QTreeNodesList objectsDeleted(const DocumentPtr& theDoc, const QString& theGroup)
  { return QTreeNodesList(); }
 
  virtual ModuleBase_IWorkshop* workshop() const { return parent()->workshop(); }
 
  virtual DocumentPtr document() const { return parent()->document(); }
 
  virtual ModuleBase_ITreeNode* findParent(const DocumentPtr& theDoc, QString theGroup)
  { return 0; }
 
  virtual ModuleBase_ITreeNode* findRoot(const DocumentPtr& theDoc)
  {
    if (document() == theDoc)
      return this;
    ModuleBase_ITreeNode* aRoot;
    foreach(ModuleBase_ITreeNode* aNode, myChildren) {
      aRoot = aNode->findRoot(theDoc);
      if (aRoot)
        return aRoot;
    }
    return 0;
  }
 
  virtual VisibilityState visibilityState() const { return NoneState; }
 
protected:
 
  virtual void deleteChildren()
  {
    while (myChildren.size()) {
      ModuleBase_ITreeNode* aNode = myChildren.takeLast();
      delete aNode;
    }
  }
 
  void sortChildren() {
    if (myChildren.size() > 1) {
      int i = 0;
      ModuleBase_ITreeNode* aNode = 0;
      ObjectPtr aObject;
      int aIdx;
      int aCount = 0;
      int aSize = myChildren.size();
      int aMaxCount = aSize * aSize;
      int aShift = 0;
      while (i < aSize) {
        aCount++;
        // To avoid unlimited cycling
        if (aCount > aMaxCount)
          break;
 
        aNode = myChildren.at(i);
        aObject = aNode->object();
        if (aObject.get()) {
          aIdx = aObject->document()->index(aObject, true) + aShift;
          if (aIdx != i) {
            myChildren.removeAll(aNode);
            myChildren.insert(aIdx, aNode);
            i = 0;
            continue;
          }
        }
        else
          aShift++;
        i++;
      }
    }
  }
 
  ModuleBase_ITreeNode* myParent; 
  QTreeNodesList myChildren; 
};
 
#endif