Initial commit

Lts/Plugins/PlanEditor/symbol_favourites.cpp

@@ -0,0 +1,831 @@
+/**
+**
+** @RDE_HEADER@
+** Do all the work for complex selection operations.
+** $Id$
+** $HeadURL$
+** $Author$
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Hardware-Environment: Intel-PC
+** Software-Environment: Windows 7, Qt 5.4. ArcGIS 10.2.5
+**
+** Language ........: C++ 11
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Author ...........: Jörg Turla, SPD G, Tel. 3132
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Notes .........:
+**
+**   25.07.2016, JT  : First edition for use with Qt5
+**
+** -----------------------------------------------------------------------------------------------
+*/
+
+
+#include "symbol_favourites.h"
+#include "plan_editor.h"
+
+#include <QtCore/QIODevice>
+#include <QtCore/QMetaMethod>
+
+#include <QtXml/QDomDocument>
+#include <QtXml/QDomNode>
+#include <QtXml/QDomNodeList>
+#include <QtXml/QDomElement>
+
+
+namespace PlanEditor
+{
+
+static const char *const attributeKeyName       = "name";
+static const char *const attributeKeySymbolCode = "sidc";
+
+
+class DomNodeVisitor
+{
+public:
+
+  DomNodeVisitor()          = default;
+  virtual ~DomNodeVisitor() = default;
+  DomNodeVisitor(const DomNodeVisitor &)                = delete;
+  DomNodeVisitor   &operator = (const DomNodeVisitor &) = delete;
+
+  bool traverse(const QDomNode &node)
+  {
+    if (node.isNull())  return true;
+
+    if (!apply(node)) return false;
+
+    const QDomNodeList &childList = node.childNodes();
+    for (int i = 0; i < childList.size(); ++i)
+    {
+      if (!traverse(childList.at(i))) return false;
+    }
+    return postApply(node);
+  } // void traverse( const QDomNode & node )
+
+  bool traverse(const QDomDocument &domDoc) { return traverse(static_cast<const QDomNode &>(domDoc)); }
+
+private:
+
+  virtual bool apply(const QDomNode &) = 0;
+  virtual bool postApply(const QDomNode &)   { return true; }
+
+}; // DomVisitor
+
+
+
+class ListNodes : public DomNodeVisitor
+{
+  QList<QDomNode>   m_sidcNodes;
+  QStringList       m_sidcList;
+
+  QList<QDomNode>   m_scopeNodes;
+  QStringList       m_scopeList;
+
+  bool apply(const QDomNode &node) override;
+
+public:
+
+  explicit ListNodes(const QDomDocument &domDoc)
+    : DomNodeVisitor()
+    , m_sidcNodes()
+    , m_sidcList()
+    , m_scopeNodes()
+    , m_scopeList()
+  {
+    traverse(domDoc);
+  }
+
+  virtual ~ListNodes() = default;
+
+  const QList<QDomNode>   &nodeScopeList() const { return m_scopeNodes; }
+  const QList<QDomNode>   &nodeSidcList()  const { return m_sidcNodes;  }
+  const QStringList       &scopeList()     const { return m_scopeList;  }
+  const QStringList       &sidcList()      const { return m_sidcList;   }
+
+}; // ListNodes
+
+
+
+class FindSidc : public DomNodeVisitor
+{
+  QDomNode   m_sidcNode;
+  QString    m_sidc;
+
+  bool apply(const QDomNode &node) override;
+
+public:
+
+  FindSidc(const QDomDocument &domDoc, const QString &sidc) : DomNodeVisitor(), m_sidcNode(), m_sidc(sidc) { traverse(domDoc); }
+  virtual ~FindSidc() = default;
+
+  bool found()        const { return !m_sidcNode.isNull(); }
+  QDomNode sidcNode() const { return m_sidcNode; }
+
+}; // FindSidc
+
+
+class FindScope : public DomNodeVisitor
+{
+  QDomNode   m_scopeNode;
+  QString    m_scope;
+
+  bool apply(const QDomNode &node) override;
+
+
+public:
+
+  FindScope(const QDomDocument &domDoc, const QString &scope) : DomNodeVisitor(), m_scopeNode(), m_scope(scope) { traverse(domDoc); }
+  virtual ~FindScope() = default;
+
+  bool found()         const { return !m_scopeNode.isNull(); }
+  QDomNode scopeNode() const { return m_scopeNode;           }
+
+}; // FindScope
+
+
+class SymbolFavouritesDom;
+
+
+class IncludeOperator : public DomNodeVisitor
+{
+  SymbolFavouritesDom &m_mainFavourites;
+  QString               m_currentScope;
+
+  bool apply(const QDomNode &node) override;
+  bool postApply(const QDomNode &node) override;
+
+public:
+
+  IncludeOperator(SymbolFavouritesDom &mainFavourites, const SymbolFavourites &toInclude);
+  virtual ~IncludeOperator() = default;
+
+}; // IncludeOperator
+
+
+class CopyScopeOperator : public DomNodeVisitor
+{
+  SymbolFavourites &m_scopeFavourites;
+  QString            m_scope;
+  bool               m_doCut;
+  unsigned int       m_symbolCount;
+
+  bool apply(const QDomNode &node) override;
+  bool postApply(const QDomNode &node) override;
+
+public:
+
+  CopyScopeOperator(const SymbolFavouritesDom &mainFavourites, const QString &scope, SymbolFavourites &scopeFavourites);
+  virtual ~CopyScopeOperator() = default;
+
+  bool scopeIsNotEmpty() const { return m_symbolCount; }
+}; // CopyScopeOperator
+
+
+class VisitorVisitor : public DomNodeVisitor
+{
+  const SymbolFavourites::SymbolVisitor &m_symbolVisitor;
+  QString                                 m_currentScope;
+
+  bool apply(const QDomNode &node) override;
+  bool postApply(const QDomNode &node) override;
+
+public:
+
+  VisitorVisitor(const QDomDocument &domDoc, const SymbolFavourites::SymbolVisitor &symbolVisitor)
+    : DomNodeVisitor()
+    , m_symbolVisitor(symbolVisitor)
+    , m_currentScope()
+  {
+    traverse(domDoc);
+  } // VisitorVisitor( const QDomDocument & domDoc, const SymbolFavourites::SymbolVisitor & symbolVisitor )
+
+  virtual ~VisitorVisitor() = default;
+};
+
+
+
+SymbolFavourites::SymbolFavourites() : QObject(nullptr) {;}
+
+
+class SymbolFavouritesDom : public SymbolFavourites, virtual protected QDomDocument
+{
+  Q_OBJECT
+
+  friend FindScope;
+  friend FindSidc;
+  friend ListNodes;
+  friend IncludeOperator;
+  friend CopyScopeOperator;
+  friend VisitorVisitor;
+
+public:
+
+  enum class NodeType
+  {
+    Anything,
+    Scope,
+    Symbol
+  }; // NodeType
+
+
+  SymbolFavouritesDom() : QDomDocument(QLatin1String(m_rootNodeName) + QLatin1String("Document")), m_logger(getLogger("SymbolFavourites"))
+  {
+    if (!m_initStaticDone) initStatic();
+    QDomElement root = createElement(QLatin1String(m_rootNodeName));
+    appendChild(root);
+  }
+
+  virtual ~SymbolFavouritesDom() = default;
+
+  QStringList sidcList() const override
+  {
+    ListNodes listSidc(*this);
+    return listSidc.sidcList();
+  } // QStringList sidcList() const
+
+
+  QStringList scopeList() const override
+  {
+    ListNodes listScope(*this);
+    return listScope.scopeList();
+  } // QStringList scopeList() const
+
+
+  void addScope(const QString &scope) override
+  {
+    if (scope.isEmpty()) return;
+
+    FindScope findScope(*this, scope);
+
+    if (!findScope.found())
+      addScopeNode(scope);
+  } // void addScope( const QString & scope )
+
+
+  void addSymbolFavourite(const QString &sidc, const QString &scope, const QString &name) override
+  {
+    FindSidc  findSidc(*this, sidc);
+
+    if (findSidc.found())
+    {
+      // remove sidc node when already exists
+      removeSymbolNode(QDomNode(), findSidc.sidcNode());
+    }
+
+    QDomNode scopeNode = firstChildElement(QLatin1String(m_rootNodeName));
+
+    if (!scope.isEmpty())
+    {
+      FindScope findScope(*this, scope);
+
+      if (!findScope.found()) scopeNode = addScopeNode(scope);
+      else                    scopeNode = findScope.scopeNode();
+    }
+
+    addSymbolNode(scopeNode, scope, name, sidc);
+  } // void addSymbolFavourite( const QString & sidc, const QString & scope, const QString & name ) override
+
+
+  bool isFavourite(const QString &sidc) const override
+  {
+    FindSidc  findSidc(*this, sidc);
+    return findSidc.found();
+  } //  bool isFavourite( const QString & sidc ) const
+
+
+  QString scope(const QString &sidc) const override
+  {
+    FindSidc  findSidc(*this, sidc);
+
+    if (findSidc.found())
+    {
+      QDomElement symbolNode   = findSidc.sidcNode().toElement();
+      if (!symbolNode.isNull())
+      {
+        QDomElement scopeNode = symbolNode.parentNode().toElement();
+        if (!scopeNode.isNull())
+        {
+          // In case of symbol node has any scope it is parent of root node
+          // and scope is then an empty string.
+          return scopeNode.attribute(QLatin1String(attributeKeyName), QString());
+        }
+      }
+    }
+    return QString();
+  } // QString scope( const QString & sidc ) const
+
+
+  QString name(const QString &sidc) const override
+  {
+    FindSidc  findSidc(*this, sidc);
+
+    if (findSidc.found())
+    {
+      QDomElement symbolNode   = findSidc.sidcNode().toElement();
+      if (!symbolNode.isNull())
+        return symbolNode.attribute(QLatin1String(attributeKeyName));
+    }
+    return QString();
+  } // QString name( const QString & sidc ) const
+
+
+  void removeSymbolFavourite(const QString &sidc) override
+  {
+    FindSidc  findSidc(*this, sidc);
+
+    if (findSidc.found())
+    {
+      // remove sidc node when already exists
+      removeSymbolNode(QDomNode(), findSidc.sidcNode());
+    }
+  } // void removeSymbolFavourite( const QString & sidc )
+
+
+  void removeScope(const QString &scope) override
+  {
+    FindScope findScope(*this, scope);
+
+    if (findScope.found())
+      removeScopeNode(findScope.scopeNode());
+  } //  void removeScope( const QString & scope )
+
+
+  void includeSymbolFavourites(const SymbolFavourites &toInclude) override
+  {
+    IncludeOperator incOp(*this, toInclude);
+  } // void includeSymbolFavourites( const SymbolFavourites & toInclude )
+
+
+  bool copyScope(const QString &scope, SymbolFavourites &scopeSymbols) override
+  {
+    CopyScopeOperator copyOp(*this, scope, scopeSymbols);
+    return copyOp.scopeIsNotEmpty();
+  } // bool copyScope( const QString & scope, SymbolFavourites & scopeSymbols )
+
+
+  QString toString() override { return QDomDocument::toString(3); }
+
+
+  class UpdateVisitor : public SymbolFavourites::SymbolVisitor
+  {
+  public:
+
+    UpdateVisitor(SymbolFavouritesDom *fav, bool construction) : m_favourites(fav), m_construction(construction) {;}
+
+  private:
+
+    SymbolFavouritesDom *m_favourites;
+    bool                  m_construction;
+
+    bool apply(const QString &scope) const override
+    {
+      if (m_construction) m_favourites -> emitSignalNewScope(scope);
+      else                m_favourites -> emitSignalDeleteScope(scope);
+      return true;
+    }
+
+
+    bool apply(const QString &scope, const QString &name, const QString &sidc) const override
+    {
+      Q_UNUSED(name);
+
+      if (m_construction) m_favourites -> emitSignalNewSymbol(scope, sidc);
+      else                m_favourites -> emitSignalDeleteSymbol(sidc);
+      return true;
+    }
+
+  }; // UpdateVisitor
+
+
+  bool contentFromString(const QString &xml) override
+  {
+    if (xml.isEmpty()) return true;
+
+    const QString &backup = toString();
+
+    QString errorMsg;
+    int     errorLine;
+    int     errorColumn;
+
+    if (!setContent(xml, &errorMsg, &errorLine, &errorColumn))
+    {
+      ERROR_LOG(m_logger) << LOGFUNCTION << " parsing xml input failed: " << errorMsg << " at line " << errorLine << " , column " << errorColumn;
+      setContent(backup);
+      return false;
+    }
+    VisitorVisitor update(*this, UpdateVisitor(this, true));
+    return true;
+  } // bool contentFromString(const QString & xml) override
+
+
+  bool contentFromDevice(QIODevice *device) override
+  {
+    if (nullptr == device) return false;
+
+    const QString &backup = toString();
+
+    QString errorMsg;
+    int     errorLine;
+    int     errorColumn;
+
+    if (!setContent(device, &errorMsg, &errorLine, &errorColumn))
+    {
+      ERROR_LOG(m_logger) << LOGFUNCTION << " parsing xml input failed: " << errorMsg << " at line " << errorLine << " , column " << errorColumn;
+      setContent(backup);
+      return false;
+    }
+    VisitorVisitor update(*this, UpdateVisitor(this, true));
+    return true;
+  } // bool contentFromDevice( const QIODevice * device ) override
+
+
+  void traverse(const SymbolVisitor &symbolVisitor) override  { VisitorVisitor visitorVisitor(*this, symbolVisitor); }
+
+
+  void emitSignalNewScope(const QString &scope)                       { emit signalNewScope(scope);        }
+  void emitSignalNewSymbol(const QString &scope, const QString &sidc) { emit signalNewSymbol(scope, sidc); }
+
+  void emitSignalDeleteScope(const QString &scope)  { emit signalDeleteScope(scope); }
+  void emitSignalDeleteSymbol(const QString &sidc)  { emit signalDeleteSymbol(sidc); }
+
+
+private:
+
+
+  QDomElement addScopeNode(const QString &scope)
+  {
+    QDomElement root      = firstChildElement(QLatin1String(m_rootNodeName));
+    QDomElement scopeNode = createElement(m_nodeTagStrings[NodeType::Scope]);
+
+    scopeNode.setAttribute(QLatin1String(attributeKeyName), scope);
+    root.appendChild(scopeNode);
+
+    emitSignalNewScope(scope);
+
+    return scopeNode;
+  } // QDomElement addScopeNode( const QString & scope )
+
+
+  QDomElement addSymbolNode(QDomNode &scopeNode, const QString &scope, const QString &name, const QString &sidc)
+  {
+    QDomElement symbolNode = createElement(m_nodeTagStrings[NodeType::Symbol]);
+    symbolNode.setAttribute(QLatin1String(attributeKeyName), name);
+    symbolNode.setAttribute(QLatin1String(attributeKeySymbolCode), sidc);
+    scopeNode.appendChild(symbolNode);
+
+    emit signalNewSymbol(scope, sidc);
+
+    return symbolNode;
+  } //  QDomElement addSymbolNode( QDomNode & scopeNode, const QString & name, const QString & sidc )
+
+
+  void removeScopeNode(const QDomNode &scopeNode)
+  {
+    QDomNode parent = scopeNode.parentNode();
+    if (!parent.isNull())
+    {
+      const QDomNodeList &childList = scopeNode.childNodes();
+      for (int i = 0; i < childList.size(); ++i)
+        removeSymbolNode(scopeNode, childList.at(i));
+
+      if (isSignalConnected(QMetaMethod::fromSignal(&SymbolFavourites::signalDeleteScope)))
+      {
+        const QDomElement &scopeElem = scopeNode.toElement();
+        const QString      &scope     = scopeElem.attribute(QLatin1String(attributeKeyName), QString());;
+        emit signalDeleteScope(scope);
+      }
+
+      parent.removeChild(scopeNode);
+    }
+  } // void removeScopeNode( QDomNode & scopeNode )
+
+
+  void removeSymbolNode(const QDomNode &scopeNode, const QDomNode &symbolNode)
+  {
+    if (symbolNode.isNull()) return;
+
+    QDomNode parent = scopeNode;
+
+    if (parent.isNull()) parent = symbolNode.parentNode();
+
+    if (!parent.isNull())
+    {
+      if (isSignalConnected(QMetaMethod::fromSignal(&SymbolFavourites::signalDeleteSymbol)))
+      {
+        const QDomElement &symbolElem = symbolNode.toElement();
+        const QString      &sidc       = symbolElem.attribute(QLatin1String(attributeKeySymbolCode), QString());;
+        emit signalDeleteSymbol(sidc);
+      }
+      parent.removeChild(symbolNode);
+    }
+  } // void removeSymbolNode( const QDomNode & symbolNode )
+
+
+  Logger &m_logger;
+
+  static bool                      m_initStaticDone;
+  static const char *const        m_rootNodeName;
+  static QMap<QString, NodeType>   m_nodeTags;
+  static QMap<NodeType, QString>   m_nodeTagStrings;
+
+  static NodeType nodeType(const QDomNode &node)
+  {
+    const QString &tag = node.nodeName();
+    return (m_nodeTags.contains(tag)) ? m_nodeTags[tag] : NodeType::Anything;
+  } // NodeType nodeType( const QDomNode & node )
+
+  static void initStatic();
+
+}; // SymbolFavouritesDom
+
+
+SymbolFavourites *SymbolFavourites::create() { return new SymbolFavouritesDom(); }
+
+
+SymbolFavourites *SymbolFavourites::createFromString(const QString &xml)
+{
+  SymbolFavouritesDom *domDoc = new SymbolFavouritesDom();
+
+  if (domDoc->contentFromString(xml))   return domDoc;
+
+  delete domDoc;
+  return nullptr;
+} // SymbolFavourites * SymbolFavourites::createFromString( const QString & xml )
+
+
+SymbolFavourites *SymbolFavourites::createFromDevice(QIODevice *device)
+{
+  SymbolFavouritesDom *domDoc = new SymbolFavouritesDom();
+
+  if (domDoc->contentFromDevice(device))  return domDoc;
+
+  delete domDoc;
+  return nullptr;
+} // SymbolFavourites * SymbolFavourites::createFromDevice( QIODevice * device )
+
+
+const char *const                           SymbolFavouritesDom::m_rootNodeName   = "SymbolFavourites";
+bool                                         SymbolFavouritesDom::m_initStaticDone = false;
+QMap<QString, SymbolFavouritesDom::NodeType> SymbolFavouritesDom::m_nodeTags;
+QMap<SymbolFavouritesDom::NodeType, QString> SymbolFavouritesDom::m_nodeTagStrings;
+
+
+void SymbolFavouritesDom::initStatic()
+{
+  m_nodeTags[QLatin1String("Scope")]  = NodeType::Scope;
+  m_nodeTags[QLatin1String("Symbol")] = NodeType::Symbol;
+
+  m_nodeTagStrings[NodeType::Scope ] = QLatin1String("Scope");
+  m_nodeTagStrings[NodeType::Symbol] = QLatin1String("Symbol");
+
+  m_initStaticDone = true;
+} // void SymbolFavouritesDom::initStatic()
+
+
+bool ListNodes::apply(const QDomNode &node)
+{
+  const QString &tag = node.nodeName();
+  if (SymbolFavouritesDom::m_nodeTags.contains(tag))
+  {
+    switch (SymbolFavouritesDom::m_nodeTags[tag])
+    {
+    case SymbolFavouritesDom::NodeType::Symbol:
+    {
+      QDomElement e = node.toElement();
+      if (e.hasAttribute(QLatin1String(attributeKeySymbolCode)))
+      {
+        m_sidcNodes += node;
+        m_sidcList  += e.attribute(QLatin1String(attributeKeySymbolCode));
+      }
+    } break;
+
+    case SymbolFavouritesDom::NodeType::Scope:
+    {
+      QDomElement e = node.toElement();
+      if (e.hasAttribute(QLatin1String(attributeKeyName)))
+      {
+        m_scopeNodes += node;
+        m_scopeList  += e.attribute(QLatin1String(attributeKeyName));
+      }
+    } break;
+
+    default : break;
+    }
+  }
+  return true;
+} // bool ListNodes::apply( const QDomNode & node )
+
+
+bool FindSidc::apply(const QDomNode &node)
+{
+  const QString &tag = node.nodeName();
+  if (SymbolFavouritesDom::m_nodeTags.contains(tag))
+  {
+    if (SymbolFavouritesDom::NodeType::Symbol == SymbolFavouritesDom::m_nodeTags[tag])
+    {
+      QDomElement e = node.toElement();
+
+      if (e.attribute(QLatin1String(attributeKeySymbolCode)) == m_sidc)
+      {
+        m_sidcNode = node;
+        return false;
+      }
+    }
+  }
+  return true;
+} // bool FindSidc::apply( const QDomNode & node )
+
+
+bool FindScope::apply(const QDomNode &node)
+{
+  const QString &tag = node.nodeName();
+  if (SymbolFavouritesDom::m_nodeTags.contains(tag))
+  {
+    if (SymbolFavouritesDom::NodeType::Scope == SymbolFavouritesDom::m_nodeTags[tag])
+    {
+      QDomElement e = node.toElement();
+      if (e.attribute(QLatin1String(attributeKeyName)) == m_scope)
+      {
+        m_scopeNode = node;
+        return false;
+      }
+    }
+  }
+  return true;
+} // bool FindScope::apply( const QDomNode & node )
+
+
+IncludeOperator::IncludeOperator(SymbolFavouritesDom &mainFavourites, const SymbolFavourites &toInclude)
+  : DomNodeVisitor()
+  , m_mainFavourites(mainFavourites)
+  , m_currentScope()
+{
+  const SymbolFavouritesDom *toIncludeDom = dynamic_cast<const SymbolFavouritesDom *>(&toInclude);
+  if (toIncludeDom)
+    traverse(*toIncludeDom);
+  else ERROR_LOG(mainFavourites.m_logger) << LOGFUNCTION << " Type mismatch: SymbolFavourites toInclude have wrong type.";
+
+} // IncludeOperator::IncludeOperator( SymbolFavouritesDom & mainFavourites, SymbolFavouritesDom & toInclude )
+
+
+bool IncludeOperator::apply(const QDomNode &node)
+{
+  const QString &tag = node.nodeName();
+
+  switch (SymbolFavouritesDom::m_nodeTags[tag])
+  {
+  case SymbolFavouritesDom::NodeType::Scope:
+  {
+    QDomElement     elmt  = node.toElement();
+    const QString &scope = elmt.attribute(QLatin1String(attributeKeyName));
+
+    m_mainFavourites.addScope(scope);
+
+    m_currentScope = scope;
+
+  } break;
+
+  case SymbolFavouritesDom::NodeType::Symbol:
+  {
+    QDomElement     elmt = node.toElement();
+    const QString &name = elmt.attribute(QLatin1String(attributeKeyName));
+    const QString &sidc = elmt.attribute(QLatin1String(attributeKeySymbolCode));
+
+    m_mainFavourites.addSymbolFavourite(sidc, m_currentScope, name);
+  } break;
+
+  default : break;
+  }
+  return true;
+} // bool IncludeOperator::apply( const QDomNode & node )
+
+
+bool IncludeOperator::postApply(const QDomNode &node)
+{
+  // if scope node has been processed reset m_currentScope
+  const QString &tag = node.nodeName();
+  if (SymbolFavouritesDom::NodeType::Scope == SymbolFavouritesDom::m_nodeTags[tag])
+    m_currentScope.clear();
+  return true;
+} // bool IncludeOperator::postApply( const QDomNode & node )
+
+
+CopyScopeOperator::CopyScopeOperator(const SymbolFavouritesDom &mainFavourites, const QString &scope, SymbolFavourites &scopeFavourites)
+  : DomNodeVisitor()
+  , m_scopeFavourites(scopeFavourites)
+  , m_scope(scope)
+  , m_doCut(false)
+  , m_symbolCount(0)
+{
+  traverse(mainFavourites);
+} // CopyScopeOperator::CopyScopeOperator( SymbolFavouritesDom & mainFavourites, const QString & scope, SymbolFavouritesDom & scopeFavourites )
+
+
+bool CopyScopeOperator::apply(const QDomNode &node)
+{
+  const QString &tag = node.nodeName();
+
+  switch (SymbolFavouritesDom::m_nodeTags[tag])
+  {
+  case SymbolFavouritesDom::NodeType::Scope:
+  {
+    QDomElement     elmt  = node.toElement();
+    const QString &scope = elmt.attribute(QLatin1String(attributeKeyName));
+
+    if (scope == m_scope)
+    {
+      m_scopeFavourites.addScope(scope);
+      m_doCut = true;
+    }
+
+  } break;
+
+  case SymbolFavouritesDom::NodeType::Symbol:
+  {
+    if (m_doCut)
+    {
+      QDomElement     elmt = node.toElement();
+      const QString &name = elmt.attribute(QLatin1String(attributeKeyName));
+      const QString &sidc = elmt.attribute(QLatin1String(attributeKeySymbolCode));
+
+      m_scopeFavourites.addSymbolFavourite(sidc, m_scope, name);
+      m_symbolCount++;
+    }
+  } break;
+
+  default: break;
+  }
+  return true;
+} //  bool CopyScopeOperator::apply( const QDomNode & node )
+
+
+bool CopyScopeOperator::postApply(const QDomNode &node)
+{
+  if (m_doCut)
+  {
+    // if scope node has been processed reset m_currentScope
+    const QString &tag = node.nodeName();
+    if (SymbolFavouritesDom::NodeType::Scope == SymbolFavouritesDom::m_nodeTags[tag])
+    {
+      m_doCut = false;
+      return false;
+    }
+  }
+  return true;
+} // bool CopyScopeOperator::postApply( const QDomNode & node )
+
+
+bool VisitorVisitor::apply(const QDomNode &node)
+{
+  const QString &tag = node.nodeName();
+
+  switch (SymbolFavouritesDom::m_nodeTags[tag])
+  {
+  case SymbolFavouritesDom::NodeType::Scope:
+  {
+    QDomElement elmt = node.toElement();
+    m_currentScope   = elmt.attribute(QLatin1String(attributeKeyName));
+
+    return m_symbolVisitor.apply(m_currentScope);
+
+  } break;
+
+  case SymbolFavouritesDom::NodeType::Symbol:
+  {
+    QDomElement     elmt = node.toElement();
+    const QString &name = elmt.attribute(QLatin1String(attributeKeyName));
+    const QString &sidc = elmt.attribute(QLatin1String(attributeKeySymbolCode));
+
+    return m_symbolVisitor.apply(m_currentScope, name, sidc);
+
+  } break;
+
+  default: break;
+  }
+  return true;
+} //  bool VisitorVisitor::apply( const QDomNode & node )
+
+
+bool VisitorVisitor::postApply(const QDomNode &node)
+{
+  const QString &tag = node.nodeName();
+  if (SymbolFavouritesDom::NodeType::Scope == SymbolFavouritesDom::m_nodeTags[tag])
+    m_currentScope.clear();
+  return true;
+} // bool VisitorVisitor::postApply( const QDomNode & node )
+
+
+bool SymbolFavourites::SymbolVisitor::apply(const QString &)                                 const { return true; }
+bool SymbolFavourites::SymbolVisitor::apply(const QString &, const QString &, const QString &) const { return true; }
+
+
+} // namespace PlanEditor
+
+#include "symbol_favourites.moc"