832 lines
23 KiB
C++
Executable File
832 lines
23 KiB
C++
Executable File
/**
|
|
**
|
|
** @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"
|