mirror of https://github.com/JakubMelka/PDF4QT.git
1917 lines
56 KiB
C++
1917 lines
56 KiB
C++
// Copyright (C) 2020-2021 Jakub Melka
|
|
//
|
|
// This file is part of PDF4QT.
|
|
//
|
|
// PDF4QT 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 3 of the License, or
|
|
// with the written consent of the copyright owner, any later version.
|
|
//
|
|
// PDF4QT 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 PDF4QT. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
#include "codegenerator.h"
|
|
|
|
#include <QFile>
|
|
#include <QTextStream>
|
|
#include <QTextLayout>
|
|
#include <QApplication>
|
|
#include <QFontMetrics>
|
|
|
|
namespace codegen
|
|
{
|
|
|
|
GeneratedCodeStorage::GeneratedCodeStorage(QObject* parent) :
|
|
BaseClass(parent)
|
|
{
|
|
|
|
}
|
|
|
|
QObjectList GeneratedCodeStorage::getFunctions() const
|
|
{
|
|
return m_functions;
|
|
}
|
|
|
|
void GeneratedCodeStorage::setFunctions(const QObjectList& functions)
|
|
{
|
|
m_functions = functions;
|
|
|
|
auto comparator = [](const QObject* left, const QObject* right)
|
|
{
|
|
const GeneratedFunction* leftFunction = qobject_cast<const GeneratedFunction*>(left);
|
|
const GeneratedFunction* rightFunction = qobject_cast<const GeneratedFunction*>(right);
|
|
return leftFunction->getFunctionName() < rightFunction->getFunctionName();
|
|
};
|
|
std::sort(m_functions.begin(), m_functions.end(), comparator);
|
|
}
|
|
|
|
GeneratedFunction* GeneratedCodeStorage::addFunction(const QString& name)
|
|
{
|
|
GeneratedFunction* function = new GeneratedFunction(this);
|
|
function->setFunctionName(name);
|
|
m_functions.append(function);
|
|
return function;
|
|
}
|
|
|
|
GeneratedFunction* GeneratedCodeStorage::addFunction(GeneratedFunction* function)
|
|
{
|
|
function->setParent(this);
|
|
m_functions.append(function);
|
|
return function;
|
|
}
|
|
|
|
void GeneratedCodeStorage::removeFunction(GeneratedFunction* function)
|
|
{
|
|
function->deleteLater();
|
|
m_functions.removeOne(function);
|
|
}
|
|
|
|
void GeneratedCodeStorage::generateCode(QTextStream& stream, CodeGeneratorParameters& parameters) const
|
|
{
|
|
stream << Qt::endl << Qt::endl;
|
|
|
|
for (const QObject* object : m_functions)
|
|
{
|
|
const GeneratedFunction* generatedFunction = qobject_cast<const GeneratedFunction*>(object);
|
|
generatedFunction->generateCode(stream, parameters);
|
|
stream << Qt::endl << Qt::endl;
|
|
}
|
|
}
|
|
|
|
QObject* Serializer::load(const QDomElement& element, QObject* parent)
|
|
{
|
|
QString className = element.attribute("class");
|
|
const QMetaObject* metaObject = QMetaType::fromName(QByteArrayView(className.toLatin1())).metaObject();
|
|
|
|
if (metaObject)
|
|
{
|
|
QObject* deserializedObject = metaObject->newInstance(Q_ARG(QObject*, parent));
|
|
|
|
const int propertyCount = metaObject->propertyCount();
|
|
for (int i = 0; i < propertyCount; ++i)
|
|
{
|
|
QMetaProperty property = metaObject->property(i);
|
|
if (property.isWritable())
|
|
{
|
|
// Find, if property was serialized
|
|
QDomElement propertyElement;
|
|
QDomNodeList children = element.childNodes();
|
|
for (int iChild = 0; iChild < children.count(); ++iChild)
|
|
{
|
|
QDomNode child = children.item(iChild);
|
|
if (child.isElement())
|
|
{
|
|
QDomElement childElement = child.toElement();
|
|
QString attributeName = childElement.attribute("name");
|
|
if (attributeName == property.name())
|
|
{
|
|
propertyElement = child.toElement();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!propertyElement.isNull())
|
|
{
|
|
// Deserialize the element
|
|
if (property.isEnumType())
|
|
{
|
|
QMetaEnum metaEnum = property.enumerator();
|
|
Q_ASSERT(metaEnum.isValid());
|
|
property.write(deserializedObject, metaEnum.keyToValue(propertyElement.text().toLatin1().data()));
|
|
}
|
|
else if (property.userType() == qMetaTypeId<QObjectList>())
|
|
{
|
|
QObjectList objectList;
|
|
QDomNodeList subChildren = propertyElement.childNodes();
|
|
for (int iChild = 0; iChild < subChildren.count(); ++iChild)
|
|
{
|
|
QDomNode node = subChildren.item(iChild);
|
|
if (node.isElement())
|
|
{
|
|
QDomElement nodeElement = node.toElement();
|
|
if (QObject* object = Serializer::load(nodeElement, deserializedObject))
|
|
{
|
|
objectList.append(object);
|
|
}
|
|
}
|
|
}
|
|
|
|
property.write(deserializedObject, QVariant::fromValue(qMove(objectList)));
|
|
}
|
|
else
|
|
{
|
|
QVariant value = propertyElement.text();
|
|
property.write(deserializedObject, value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return deserializedObject;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void Serializer::store(QObject* object, QDomElement& element)
|
|
{
|
|
Q_ASSERT(object);
|
|
|
|
const QMetaObject* metaObject = object->metaObject();
|
|
element.setAttribute("class", QString(metaObject->className()));
|
|
|
|
const int propertyCount = metaObject->propertyCount();
|
|
if (propertyCount > 0)
|
|
{
|
|
for (int i = 0; i < propertyCount; ++i)
|
|
{
|
|
QMetaProperty property = metaObject->property(i);
|
|
if (property.isReadable())
|
|
{
|
|
QDomElement propertyElement = element.ownerDocument().createElement("property");
|
|
element.appendChild(propertyElement);
|
|
propertyElement.setAttribute("name", property.name());
|
|
|
|
QVariant value = property.read(object);
|
|
if (property.isEnumType())
|
|
{
|
|
QMetaEnum metaEnum = property.enumerator();
|
|
Q_ASSERT(metaEnum.isValid());
|
|
propertyElement.appendChild(propertyElement.ownerDocument().createTextNode(metaEnum.valueToKey(value.toInt())));
|
|
}
|
|
else if (value.canConvert<QObjectList>())
|
|
{
|
|
QObjectList objectList = value.value<QObjectList>();
|
|
for (QObject* currentObject : objectList)
|
|
{
|
|
QDomElement objectElement = element.ownerDocument().createElement("QObject");
|
|
propertyElement.appendChild(objectElement);
|
|
Serializer::store(currentObject, objectElement);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
propertyElement.appendChild(propertyElement.ownerDocument().createTextNode(value.toString()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
QObject* Serializer::clone(QObject* object, QObject* parent)
|
|
{
|
|
QDomDocument document;
|
|
QDomElement rootElement = document.createElement("root");
|
|
document.appendChild(rootElement);
|
|
Serializer::store(object, rootElement);
|
|
return Serializer::load(rootElement, parent);
|
|
}
|
|
|
|
CodeGenerator::CodeGenerator(QObject* parent) :
|
|
BaseClass(parent)
|
|
{
|
|
qRegisterMetaType<GeneratedCodeStorage*>("codegen::GeneratedCodeStorage");
|
|
qRegisterMetaType<GeneratedFunction*>("codegen::GeneratedFunction");
|
|
qRegisterMetaType<GeneratedBase*>("codegen::GeneratedBase");
|
|
qRegisterMetaType<GeneratedParameter*>("codegen::GeneratedParameter");
|
|
qRegisterMetaType<GeneratedPDFObject*>("codegen::GeneratedPDFObject");
|
|
qRegisterMetaType<GeneratedAction*>("codegen::GeneratedAction");
|
|
qRegisterMetaType<QObjectList>("QObjectList");
|
|
}
|
|
|
|
void CodeGenerator::initialize()
|
|
{
|
|
m_storage = new GeneratedCodeStorage(this);
|
|
}
|
|
|
|
void CodeGenerator::load(const QDomDocument& document)
|
|
{
|
|
delete m_storage;
|
|
m_storage = nullptr;
|
|
|
|
m_storage = qobject_cast<GeneratedCodeStorage*>(Serializer::load(document.firstChildElement("root"), this));
|
|
}
|
|
|
|
void CodeGenerator::store(QDomDocument& document)
|
|
{
|
|
if (m_storage)
|
|
{
|
|
QDomElement rootElement = document.createElement("root");
|
|
document.appendChild(rootElement);
|
|
Serializer::store(m_storage, rootElement);
|
|
}
|
|
}
|
|
|
|
void CodeGenerator::generateCode(QString headerName, QString sourceName) const
|
|
{
|
|
QString startMark = "/* START GENERATED CODE */";
|
|
QString endMark = "/* END GENERATED CODE */";
|
|
QString className = "PDFDocumentBuilder";
|
|
const int indent = 4;
|
|
|
|
QFile headerFile(headerName);
|
|
if (headerFile.exists())
|
|
{
|
|
if (headerFile.open(QFile::ReadOnly | QFile::Text))
|
|
{
|
|
QString utfCode = QString::fromUtf8(headerFile.readAll());
|
|
headerFile.close();
|
|
|
|
int startIndex = utfCode.indexOf(startMark, Qt::CaseSensitive) + startMark.length();
|
|
int endIndex = utfCode.indexOf(endMark, Qt::CaseSensitive);
|
|
|
|
QString frontPart = utfCode.left(startIndex);
|
|
QString backPart = utfCode.mid(endIndex);
|
|
QString headerGeneratedCode = generateHeader(indent);
|
|
QString allCode = frontPart + headerGeneratedCode + backPart;
|
|
|
|
headerFile.open(QFile::WriteOnly | QFile::Truncate);
|
|
headerFile.write(allCode.toUtf8());
|
|
headerFile.close();
|
|
}
|
|
}
|
|
|
|
QFile sourceFile(sourceName);
|
|
if (sourceFile.exists())
|
|
{
|
|
if (sourceFile.open(QFile::ReadOnly | QFile::Text))
|
|
{
|
|
QString utfCode = QString::fromUtf8(sourceFile.readAll());
|
|
sourceFile.close();
|
|
|
|
int startIndex = utfCode.indexOf(startMark, Qt::CaseSensitive) + startMark.length();
|
|
int endIndex = utfCode.indexOf(endMark, Qt::CaseSensitive);
|
|
|
|
QString frontPart = utfCode.left(startIndex);
|
|
QString backPart = utfCode.mid(endIndex);
|
|
QString sourceGeneratedCode = generateSource(className, indent);
|
|
QString allCode = frontPart + sourceGeneratedCode + backPart;
|
|
|
|
sourceFile.open(QFile::WriteOnly | QFile::Truncate);
|
|
sourceFile.write(allCode.toUtf8());
|
|
sourceFile.close();
|
|
}
|
|
}
|
|
}
|
|
|
|
QString CodeGenerator::generateHeader(int indent) const
|
|
{
|
|
QByteArray ba;
|
|
{
|
|
QTextStream stream(&ba, QIODevice::WriteOnly);
|
|
stream.setEncoding(QStringConverter::Utf8);
|
|
stream.setRealNumberPrecision(3);
|
|
stream.setRealNumberNotation(QTextStream::FixedNotation);
|
|
|
|
CodeGeneratorParameters parameters;
|
|
parameters.header = true;
|
|
parameters.indent = indent;
|
|
m_storage->generateCode(stream, parameters);
|
|
}
|
|
|
|
return QString::fromUtf8(ba);
|
|
}
|
|
|
|
QString CodeGenerator::generateSource(QString className, int indent) const
|
|
{
|
|
QByteArray ba;
|
|
{
|
|
QTextStream stream(&ba, QIODevice::WriteOnly);
|
|
stream.setEncoding(QStringConverter::Utf8);
|
|
stream.setRealNumberPrecision(3);
|
|
stream.setRealNumberNotation(QTextStream::FixedNotation);
|
|
|
|
CodeGeneratorParameters parameters;
|
|
parameters.header = false;
|
|
parameters.indent = indent;
|
|
parameters.className = className;
|
|
m_storage->generateCode(stream, parameters);
|
|
}
|
|
|
|
return QString::fromUtf8(ba);
|
|
}
|
|
|
|
GeneratedFunction::GeneratedFunction(QObject* parent) :
|
|
BaseClass(parent)
|
|
{
|
|
|
|
}
|
|
|
|
QString GeneratedFunction::getFunctionTypeString() const
|
|
{
|
|
return Serializer::convertEnumToString(m_functionType);
|
|
}
|
|
|
|
void GeneratedFunction::setFunctionTypeString(const QString& string)
|
|
{
|
|
Serializer::convertStringToEnum<decltype(m_functionType)>(string, m_functionType);
|
|
}
|
|
|
|
GeneratedFunction::FunctionType GeneratedFunction::getFunctionType() const
|
|
{
|
|
return m_functionType;
|
|
}
|
|
|
|
void GeneratedFunction::setFunctionType(const FunctionType& functionType)
|
|
{
|
|
m_functionType = functionType;
|
|
}
|
|
|
|
QString GeneratedFunction::getFunctionName() const
|
|
{
|
|
return m_functionName;
|
|
}
|
|
|
|
void GeneratedFunction::setFunctionName(const QString& functionName)
|
|
{
|
|
m_functionName = functionName;
|
|
}
|
|
|
|
QString GeneratedFunction::getFunctionDescription() const
|
|
{
|
|
return m_functionDescription;
|
|
}
|
|
|
|
void GeneratedFunction::setFunctionDescription(const QString& functionDescription)
|
|
{
|
|
m_functionDescription = functionDescription;
|
|
}
|
|
|
|
GeneratedFunction* GeneratedFunction::clone(QObject* parent)
|
|
{
|
|
return qobject_cast<GeneratedFunction*>(Serializer::clone(this, parent));
|
|
}
|
|
|
|
void GeneratedFunction::generateCode(QTextStream& stream, CodeGeneratorParameters& parameters) const
|
|
{
|
|
QStringList parameterCaptions;
|
|
QStringList parameterTexts;
|
|
std::function<void (const GeneratedBase*, Pass)> gatherParameters = [&](const GeneratedBase* object, Pass pass)
|
|
{
|
|
if (pass != Pass::Enter)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (const GeneratedParameter* generatedParameter = qobject_cast<const GeneratedParameter*>(object))
|
|
{
|
|
parameterCaptions << QString("%1 %2").arg(generatedParameter->getParameterName(), generatedParameter->getParameterDescription());
|
|
parameterTexts << QString("%1 %2").arg(getCppType(generatedParameter->getParameterDataType()), generatedParameter->getParameterName());
|
|
}
|
|
};
|
|
applyFunctor(gatherParameters);
|
|
|
|
if (parameterTexts.isEmpty())
|
|
{
|
|
parameterTexts << "";
|
|
}
|
|
|
|
if (parameters.header)
|
|
{
|
|
// Generate header source code
|
|
|
|
// Function comments
|
|
for (const QString& string : getFormattedTextWithLayout("/// ", "/// ", getFunctionDescription(), parameters.indent))
|
|
{
|
|
stream << string << Qt::endl;
|
|
}
|
|
|
|
// Function parameter comments
|
|
for (const QString& parameterCaption : parameterCaptions)
|
|
{
|
|
for (const QString& string : getFormattedTextWithLayout("/// \\param ", "/// ", parameterCaption, parameters.indent))
|
|
{
|
|
stream << string << Qt::endl;
|
|
}
|
|
}
|
|
|
|
// Function declaration
|
|
QString functionHeader = QString("%1 %2(").arg(getCppType(getReturnType()), getFunctionName());
|
|
QString functionHeaderNext(functionHeader.length(), QChar(QChar::Space));
|
|
QString functionFooter = QString(");");
|
|
|
|
for (QString& str : parameterTexts)
|
|
{
|
|
str += ",";
|
|
}
|
|
parameterTexts.back().replace(",", functionFooter);
|
|
|
|
QStringList functionDeclaration = getFormattedTextBlock(functionHeader, functionHeaderNext, parameterTexts, parameters.indent);
|
|
for (const QString& functionDeclarationItem : functionDeclaration)
|
|
{
|
|
stream << functionDeclarationItem << Qt::endl;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Generate c++ source code
|
|
QString functionHeader = QString("%1 %2::%3(").arg(getCppType(getReturnType()), parameters.className, getFunctionName());
|
|
QString functionHeaderNext(functionHeader.length(), QChar(QChar::Space));
|
|
QString functionFooter = QString(")");
|
|
|
|
for (QString& str : parameterTexts)
|
|
{
|
|
str += ",";
|
|
}
|
|
parameterTexts.back().replace(",", functionFooter);
|
|
|
|
QStringList functionDeclaration = getFormattedTextBlock(functionHeader, functionHeaderNext, parameterTexts, 0);
|
|
for (const QString& functionDeclarationItem : functionDeclaration)
|
|
{
|
|
stream << functionDeclarationItem << Qt::endl;
|
|
}
|
|
|
|
QString indent(parameters.indent, QChar(QChar::Space));
|
|
|
|
stream << "{" << Qt::endl;
|
|
stream << indent << "PDFObjectFactory objectBuilder;" << Qt::endl << Qt::endl;
|
|
|
|
generateSourceCode(stream, parameters);
|
|
|
|
stream << "}" << Qt::endl;
|
|
}
|
|
}
|
|
|
|
bool GeneratedFunction::hasField(GeneratedBase::FieldType fieldType) const
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::Name:
|
|
case FieldType::ItemType:
|
|
case FieldType::DataType:
|
|
case FieldType::Description:
|
|
return true;
|
|
|
|
case FieldType::Value:
|
|
return false;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
QVariant GeneratedFunction::readField(GeneratedBase::FieldType fieldType) const
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::Name:
|
|
return m_functionName;
|
|
case FieldType::ItemType:
|
|
return int(m_functionType);
|
|
case FieldType::DataType:
|
|
return int(m_returnType);
|
|
case FieldType::Description:
|
|
return m_functionDescription;
|
|
|
|
case FieldType::Value:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
void GeneratedFunction::writeField(GeneratedBase::FieldType fieldType, QVariant value)
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::Name:
|
|
m_functionName = value.toString();
|
|
break;
|
|
case FieldType::ItemType:
|
|
m_functionType = static_cast<FunctionType>(value.toInt());
|
|
break;
|
|
case FieldType::DataType:
|
|
m_returnType = static_cast<DataType>(value.toInt());
|
|
break;
|
|
case FieldType::Description:
|
|
m_functionDescription = value.toString();
|
|
break;
|
|
|
|
case FieldType::Value:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void GeneratedFunction::fillComboBox(QComboBox* comboBox, GeneratedBase::FieldType fieldType)
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::ItemType:
|
|
Serializer::fillComboBox(comboBox, m_functionType);
|
|
break;
|
|
case FieldType::DataType:
|
|
Serializer::fillComboBox(comboBox, m_returnType);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool GeneratedFunction::canHaveSubitems() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
QStringList GeneratedFunction::getCaptions() const
|
|
{
|
|
return QStringList() << QString("Function") << QString("%1 %2(...)").arg(Serializer::convertEnumToString(m_returnType), m_functionName);
|
|
}
|
|
|
|
GeneratedBase* GeneratedFunction::appendItem()
|
|
{
|
|
Q_ASSERT(canHaveSubitems());
|
|
|
|
GeneratedBase* newItem = new GeneratedAction(this);
|
|
addItem(newItem);
|
|
return newItem;
|
|
}
|
|
|
|
GeneratedFunction::DataType GeneratedFunction::getReturnType() const
|
|
{
|
|
return m_returnType;
|
|
}
|
|
|
|
void GeneratedFunction::setReturnType(DataType returnType)
|
|
{
|
|
m_returnType = returnType;
|
|
}
|
|
|
|
GeneratedAction::GeneratedAction(QObject* parent) :
|
|
BaseClass(parent),
|
|
m_actionType(CreateObject)
|
|
{
|
|
|
|
}
|
|
|
|
bool GeneratedAction::hasField(FieldType fieldType) const
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::Name:
|
|
return m_actionType == CreateObject;
|
|
case FieldType::ItemType:
|
|
return true;
|
|
case FieldType::DataType:
|
|
return hasField(FieldType::Name) && !m_variableName.isEmpty();
|
|
case FieldType::Description:
|
|
return m_actionType == Code;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
QVariant GeneratedAction::readField(GeneratedBase::FieldType fieldType) const
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::Name:
|
|
return m_variableName;
|
|
case FieldType::ItemType:
|
|
return int(m_actionType);
|
|
case FieldType::DataType:
|
|
return int(m_variableType);
|
|
case FieldType::Description:
|
|
return m_code;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
void GeneratedAction::writeField(GeneratedBase::FieldType fieldType, QVariant value)
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::Name:
|
|
m_variableName = value.toString();
|
|
break;
|
|
case FieldType::ItemType:
|
|
m_actionType = static_cast<ActionType>(value.toInt());
|
|
break;
|
|
case FieldType::DataType:
|
|
m_variableType = static_cast<DataType>(value.toInt());
|
|
break;
|
|
case FieldType::Description:
|
|
m_code = value.toString();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void GeneratedAction::fillComboBox(QComboBox* comboBox, FieldType fieldType)
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::ItemType:
|
|
Serializer::fillComboBox(comboBox, m_actionType);
|
|
break;
|
|
case FieldType::DataType:
|
|
Serializer::fillComboBox(comboBox, m_variableType);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool GeneratedAction::canHaveSubitems() const
|
|
{
|
|
switch (m_actionType)
|
|
{
|
|
case Parameters:
|
|
case CreateObject:
|
|
return true;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
QStringList GeneratedAction::getCaptions() const
|
|
{
|
|
return QStringList() << QString("Action %1").arg(Serializer::convertEnumToString(m_actionType)) << (!m_variableName.isEmpty() ? QString("%1 %2").arg(Serializer::convertEnumToString(m_variableType), m_variableName) : QString());
|
|
}
|
|
|
|
GeneratedBase* GeneratedAction::appendItem()
|
|
{
|
|
Q_ASSERT(canHaveSubitems());
|
|
GeneratedBase* newItem = nullptr;
|
|
switch (m_actionType)
|
|
{
|
|
case Parameters:
|
|
newItem = new GeneratedParameter(this);
|
|
break;
|
|
|
|
default:
|
|
newItem = new GeneratedPDFObject(this);
|
|
break;
|
|
}
|
|
|
|
addItem(newItem);
|
|
return newItem;
|
|
}
|
|
|
|
GeneratedAction::ActionType GeneratedAction::getActionType() const
|
|
{
|
|
return m_actionType;
|
|
}
|
|
|
|
void GeneratedAction::setActionType(ActionType actionType)
|
|
{
|
|
m_actionType = actionType;
|
|
|
|
if (!canHaveSubitems())
|
|
{
|
|
clearItems();
|
|
}
|
|
}
|
|
|
|
QString GeneratedAction::getVariableName() const
|
|
{
|
|
return m_variableName;
|
|
}
|
|
|
|
void GeneratedAction::setVariableName(const QString& variableName)
|
|
{
|
|
m_variableName = variableName;
|
|
}
|
|
|
|
GeneratedAction::DataType GeneratedAction::getVariableType() const
|
|
{
|
|
return m_variableType;
|
|
}
|
|
|
|
void GeneratedAction::setVariableType(DataType variableType)
|
|
{
|
|
m_variableType = variableType;
|
|
}
|
|
|
|
QString GeneratedAction::getCode() const
|
|
{
|
|
return m_code;
|
|
}
|
|
|
|
void GeneratedAction::setCode(const QString& code)
|
|
{
|
|
m_code = code;
|
|
}
|
|
|
|
void GeneratedAction::generateSourceCodeImpl(QTextStream& stream, CodeGeneratorParameters& parameters, GeneratedBase::Pass pass) const
|
|
{
|
|
if (pass == Pass::Enter && getActionType() == Code)
|
|
{
|
|
QString indent(parameters.indent, QChar(QChar::Space));
|
|
QStringList lines = getCode().split(QChar('\n'), Qt::KeepEmptyParts, Qt::CaseInsensitive);
|
|
|
|
for (QString string : lines)
|
|
{
|
|
string = string.trimmed();
|
|
if (!string.isEmpty())
|
|
{
|
|
stream << indent << string << Qt::endl;
|
|
}
|
|
else
|
|
{
|
|
stream << Qt::endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pass == Pass::Leave && getActionType() == CreateObject)
|
|
{
|
|
QString indent(parameters.indent, QChar(QChar::Space));
|
|
|
|
switch (getVariableType())
|
|
{
|
|
case _PDFObject:
|
|
{
|
|
stream << indent << getCppType(getVariableType()) << " " << getVariableName() << " = objectBuilder.takeObject();";
|
|
break;
|
|
}
|
|
|
|
case _PDFObjectReference:
|
|
{
|
|
stream << indent << getCppType(getVariableType()) << " " << getVariableName() << " = addObject(objectBuilder.takeObject());";
|
|
break;
|
|
}
|
|
|
|
default:
|
|
Q_ASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pass == Pass::Leave && getActionType() != Parameters && !parameters.isLastItem)
|
|
{
|
|
stream << Qt::endl;
|
|
}
|
|
}
|
|
|
|
void GeneratedBase::generateSourceCode(QTextStream& stream, CodeGeneratorParameters& parameters) const
|
|
{
|
|
generateSourceCodeImpl(stream, parameters, Pass::Enter);
|
|
|
|
for (const QObject* object : m_items)
|
|
{
|
|
const GeneratedBase* generatedBase = qobject_cast<const GeneratedBase*>(object);
|
|
CodeGeneratorParameters parametersTemporary = parameters;
|
|
parametersTemporary.isFirstItem = object == m_items.front();
|
|
parametersTemporary.isLastItem = object == m_items.back();
|
|
generatedBase->generateSourceCode(stream, parametersTemporary);
|
|
}
|
|
|
|
generateSourceCodeImpl(stream, parameters, Pass::Leave);
|
|
}
|
|
|
|
void GeneratedBase::applyFunctor(std::function<void (const GeneratedBase*, Pass)>& functor) const
|
|
{
|
|
functor(this, Pass::Enter);
|
|
|
|
for (const QObject* object : m_items)
|
|
{
|
|
const GeneratedBase* generatedBase = qobject_cast<const GeneratedBase*>(object);
|
|
generatedBase->applyFunctor(functor);
|
|
}
|
|
|
|
functor(this, Pass::Leave);
|
|
}
|
|
|
|
bool GeneratedBase::canPerformOperation(Operation operation) const
|
|
{
|
|
const bool isFunction = qobject_cast<const GeneratedFunction*>(this) != nullptr;
|
|
switch (operation)
|
|
{
|
|
case Operation::Delete:
|
|
return !isFunction;
|
|
|
|
case Operation::MoveUp:
|
|
{
|
|
if (const GeneratedBase* parentBase = getParent())
|
|
{
|
|
QObjectList items = parentBase->getItems();
|
|
return items.indexOf(const_cast<codegen::GeneratedBase*>(this)) > 0;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case Operation::MoveDown:
|
|
{
|
|
if (const GeneratedBase* parentBase = getParent())
|
|
{
|
|
QObjectList items = parentBase->getItems();
|
|
return items.indexOf(const_cast<codegen::GeneratedBase*>(this)) < items.size() - 1;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case Operation::NewSibling:
|
|
return !isFunction;
|
|
|
|
case Operation::NewChild:
|
|
return canHaveSubitems();
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void GeneratedBase::performOperation(GeneratedBase::Operation operation)
|
|
{
|
|
switch (operation)
|
|
{
|
|
case Operation::Delete:
|
|
{
|
|
getParent()->removeItem(this);
|
|
break;
|
|
}
|
|
|
|
case Operation::MoveUp:
|
|
{
|
|
GeneratedBase* parentItem = getParent();
|
|
QObjectList items = parentItem->getItems();
|
|
const int index = items.indexOf(this);
|
|
items.removeAll(const_cast<codegen::GeneratedBase*>(this));
|
|
items.insert(index - 1, this);
|
|
parentItem->setItems(qMove(items));
|
|
break;
|
|
}
|
|
|
|
case Operation::MoveDown:
|
|
{
|
|
GeneratedBase* parentItem = getParent();
|
|
QObjectList items = parentItem->getItems();
|
|
const int index = items.indexOf(this);
|
|
items.removeAll(const_cast<codegen::GeneratedBase*>(this));
|
|
items.insert(index + 1, this);
|
|
parentItem->setItems(qMove(items));
|
|
break;
|
|
}
|
|
|
|
case Operation::NewSibling:
|
|
{
|
|
GeneratedBase* parentItem = getParent();
|
|
if (GeneratedBase* createdItem = parentItem->appendItem())
|
|
{
|
|
QObjectList items = parentItem->getItems();
|
|
items.removeAll(createdItem);
|
|
items.insert(items.indexOf(const_cast<codegen::GeneratedBase*>(this)) + 1, createdItem);
|
|
parentItem->setItems(qMove(items));
|
|
}
|
|
break;
|
|
}
|
|
|
|
case Operation::NewChild:
|
|
{
|
|
appendItem();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
QObjectList GeneratedBase::getItems() const
|
|
{
|
|
return m_items;
|
|
}
|
|
|
|
void GeneratedBase::setItems(const QObjectList& items)
|
|
{
|
|
m_items = items;
|
|
}
|
|
|
|
void GeneratedBase::addItem(QObject* object)
|
|
{
|
|
object->setParent(this);
|
|
m_items.append(object);
|
|
}
|
|
|
|
void GeneratedBase::removeItem(QObject* object)
|
|
{
|
|
object->deleteLater();
|
|
m_items.removeAll(object);
|
|
}
|
|
|
|
void GeneratedBase::clearItems()
|
|
{
|
|
qDeleteAll(m_items);
|
|
m_items.clear();
|
|
}
|
|
|
|
void GeneratedBase::generateSourceCodeImpl(QTextStream& stream, CodeGeneratorParameters& parameters, GeneratedBase::Pass pass) const
|
|
{
|
|
Q_UNUSED(stream);
|
|
Q_UNUSED(parameters);
|
|
Q_UNUSED(pass);
|
|
}
|
|
|
|
QString GeneratedBase::getCppType(DataType type) const
|
|
{
|
|
return Serializer::convertEnumToString(type).mid(1);
|
|
}
|
|
|
|
QStringList GeneratedBase::getFormattedTextWithLayout(QString firstPrefix, QString prefix, QString text, int indent) const
|
|
{
|
|
QFont font = QApplication::font();
|
|
QFontMetrics fontMetrics(font);
|
|
|
|
int usedLength = indent + qMax(firstPrefix.length(), prefix.length());
|
|
int length = 80 - usedLength;
|
|
QString testText(length, QChar('A'));
|
|
int width = fontMetrics.horizontalAdvance(testText);
|
|
|
|
QTextLayout layout(text, font);
|
|
layout.setCacheEnabled(false);
|
|
QTextOption textOption = layout.textOption();
|
|
textOption.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
|
|
layout.setTextOption(textOption);
|
|
|
|
layout.beginLayout();
|
|
while (true)
|
|
{
|
|
QTextLine textLine = layout.createLine();
|
|
if (!textLine.isValid())
|
|
{
|
|
break;
|
|
}
|
|
|
|
textLine.setLineWidth(width);
|
|
}
|
|
layout.endLayout();
|
|
|
|
QStringList texts;
|
|
const int lineCount = layout.lineCount();
|
|
for (int i = 0; i < lineCount; ++i)
|
|
{
|
|
QTextLine line = layout.lineAt(i);
|
|
texts << text.mid(line.textStart(), line.textLength());
|
|
}
|
|
return getFormattedTextBlock(firstPrefix, prefix, texts, indent);
|
|
}
|
|
|
|
QStringList GeneratedBase::getFormattedTextBlock(QString firstPrefix, QString prefix, QStringList texts, int indent) const
|
|
{
|
|
QString indentText(indent, QChar(QChar::Space));
|
|
firstPrefix.prepend(indentText);
|
|
prefix.prepend(indentText);
|
|
|
|
QStringList result;
|
|
QString currentPrefix = firstPrefix;
|
|
for (const QString& text : texts)
|
|
{
|
|
result << QString("%1%2").arg(currentPrefix, text);
|
|
currentPrefix = prefix;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
GeneratedPDFObject::GeneratedPDFObject(QObject* parent) :
|
|
BaseClass(parent)
|
|
{
|
|
|
|
}
|
|
|
|
bool GeneratedPDFObject::hasField(GeneratedBase::FieldType fieldType) const
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::Name:
|
|
return m_objectType == DictionaryItemSimple || m_objectType == DictionaryItemComplex;
|
|
case FieldType::ItemType:
|
|
return true;
|
|
case FieldType::Value:
|
|
return m_objectType == Object || m_objectType == ArraySimple || m_objectType == DictionaryItemSimple;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
QVariant GeneratedPDFObject::readField(GeneratedBase::FieldType fieldType) const
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::Name:
|
|
return m_dictionaryItemName;
|
|
case FieldType::ItemType:
|
|
return int(m_objectType);
|
|
case FieldType::Value:
|
|
return m_value;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
void GeneratedPDFObject::writeField(GeneratedBase::FieldType fieldType, QVariant value)
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::Name:
|
|
m_dictionaryItemName = value.toString();
|
|
break;
|
|
case FieldType::ItemType:
|
|
m_objectType = static_cast<ObjectType>(value.toInt());
|
|
break;
|
|
case FieldType::Value:
|
|
m_value = value.toString();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void GeneratedPDFObject::fillComboBox(QComboBox* comboBox, GeneratedBase::FieldType fieldType)
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::ItemType:
|
|
Serializer::fillComboBox(comboBox, m_objectType);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool GeneratedPDFObject::canHaveSubitems() const
|
|
{
|
|
switch (m_objectType)
|
|
{
|
|
case ArrayComplex:
|
|
case Dictionary:
|
|
case DictionaryItemComplex:
|
|
return true;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
QStringList GeneratedPDFObject::getCaptions() const
|
|
{
|
|
QString name;
|
|
switch (m_objectType)
|
|
{
|
|
case Object:
|
|
name = tr("Object");
|
|
break;
|
|
case ArraySimple:
|
|
name = tr("Array (simple)");
|
|
break;
|
|
case ArrayComplex:
|
|
name = tr("Array (complex)");
|
|
break;
|
|
case Dictionary:
|
|
name = tr("Dictionary");
|
|
break;
|
|
case DictionaryItemSimple:
|
|
name = tr("Item (simple), name = '%1'").arg(m_dictionaryItemName);
|
|
break;
|
|
case DictionaryItemComplex:
|
|
name = tr("Item (complex), name = '%1'").arg(m_dictionaryItemName);
|
|
break;
|
|
|
|
default:
|
|
Q_ASSERT(false);
|
|
break;
|
|
}
|
|
|
|
return QStringList() << name << m_value;
|
|
}
|
|
|
|
GeneratedBase* GeneratedPDFObject::appendItem()
|
|
{
|
|
Q_ASSERT(canHaveSubitems());
|
|
GeneratedBase* newItem = new GeneratedPDFObject(this);
|
|
addItem(newItem);
|
|
return newItem;
|
|
}
|
|
|
|
QString GeneratedPDFObject::getValue() const
|
|
{
|
|
return m_value;
|
|
}
|
|
|
|
void GeneratedPDFObject::setValue(const QString& value)
|
|
{
|
|
m_value = value;
|
|
}
|
|
|
|
GeneratedPDFObject::ObjectType GeneratedPDFObject::getObjectType() const
|
|
{
|
|
return m_objectType;
|
|
}
|
|
|
|
void GeneratedPDFObject::setObjectType(ObjectType objectType)
|
|
{
|
|
m_objectType = objectType;
|
|
|
|
if (!canHaveSubitems())
|
|
{
|
|
clearItems();
|
|
}
|
|
}
|
|
|
|
QString GeneratedPDFObject::getDictionaryItemName() const
|
|
{
|
|
return m_dictionaryItemName;
|
|
}
|
|
|
|
void GeneratedPDFObject::setDictionaryItemName(const QString& dictionaryItemName)
|
|
{
|
|
m_dictionaryItemName = dictionaryItemName;
|
|
}
|
|
|
|
void GeneratedPDFObject::generateSourceCodeImpl(QTextStream& stream, CodeGeneratorParameters& parameters, GeneratedBase::Pass pass) const
|
|
{
|
|
QString indent(parameters.indent, QChar(QChar::Space));
|
|
QString writeTo("objectBuilder << ");
|
|
|
|
switch (getObjectType())
|
|
{
|
|
case codegen::GeneratedPDFObject::Object:
|
|
{
|
|
if (pass == Pass::Enter)
|
|
{
|
|
stream << indent << writeTo << getValue().trimmed() << ";" << Qt::endl;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case codegen::GeneratedPDFObject::ArraySimple:
|
|
{
|
|
if (pass == Pass::Enter)
|
|
{
|
|
stream << indent << "objectBuilder.beginArray();" << Qt::endl;
|
|
for (const QString& arrayPart : getValue().trimmed().split(";"))
|
|
{
|
|
stream << indent << writeTo << arrayPart << ";" << Qt::endl;
|
|
}
|
|
stream << indent << "objectBuilder.endArray();" << Qt::endl;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case codegen::GeneratedPDFObject::ArrayComplex:
|
|
{
|
|
if (pass == Pass::Enter)
|
|
{
|
|
stream << indent << "objectBuilder.beginArray();" << Qt::endl;
|
|
}
|
|
if (pass == Pass::Leave)
|
|
{
|
|
stream << indent << "objectBuilder.endArray();" << Qt::endl;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case codegen::GeneratedPDFObject::Dictionary:
|
|
{
|
|
if (pass == Pass::Enter)
|
|
{
|
|
stream << indent << "objectBuilder.beginDictionary();" << Qt::endl;
|
|
}
|
|
if (pass == Pass::Leave)
|
|
{
|
|
stream << indent << "objectBuilder.endDictionary();" << Qt::endl;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case codegen::GeneratedPDFObject::DictionaryItemSimple:
|
|
{
|
|
if (pass == Pass::Enter)
|
|
{
|
|
stream << indent << QString("objectBuilder.beginDictionaryItem(\"%1\");").arg(getDictionaryItemName()) << Qt::endl;
|
|
stream << indent << writeTo << getValue().trimmed() << ";" << Qt::endl;
|
|
stream << indent << "objectBuilder.endDictionaryItem();" << Qt::endl;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case codegen::GeneratedPDFObject::DictionaryItemComplex:
|
|
{
|
|
if (pass == Pass::Enter)
|
|
{
|
|
stream << indent << QString("objectBuilder.beginDictionaryItem(\"%1\");").arg(getDictionaryItemName()) << Qt::endl;
|
|
}
|
|
if (pass == Pass::Leave)
|
|
{
|
|
stream << indent << "objectBuilder.endDictionaryItem();" << Qt::endl;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
Q_ASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
GeneratedParameter::GeneratedParameter(QObject* parent) :
|
|
BaseClass(parent)
|
|
{
|
|
|
|
}
|
|
|
|
bool GeneratedParameter::hasField(GeneratedBase::FieldType fieldType) const
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::Name:
|
|
case FieldType::DataType:
|
|
case FieldType::Description:
|
|
return true;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
QVariant GeneratedParameter::readField(GeneratedBase::FieldType fieldType) const
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::Name:
|
|
return m_parameterName;
|
|
case FieldType::DataType:
|
|
return m_parameterDataType;
|
|
case FieldType::Description:
|
|
return m_parameterDescription;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
void GeneratedParameter::writeField(GeneratedBase::FieldType fieldType, QVariant value)
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::Name:
|
|
m_parameterName = value.toString();
|
|
break;
|
|
case FieldType::DataType:
|
|
m_parameterDataType = static_cast<DataType>(value.toInt());
|
|
break;
|
|
case FieldType::Description:
|
|
m_parameterDescription = value.toString();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void GeneratedParameter::fillComboBox(QComboBox* comboBox, GeneratedBase::FieldType fieldType)
|
|
{
|
|
switch (fieldType)
|
|
{
|
|
case FieldType::DataType:
|
|
Serializer::fillComboBox(comboBox, m_parameterDataType);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool GeneratedParameter::canHaveSubitems() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
QStringList GeneratedParameter::getCaptions() const
|
|
{
|
|
return QStringList() << QString("%1 %2").arg(Serializer::convertEnumToString(m_parameterDataType)).arg(m_parameterName) << m_parameterDescription;
|
|
}
|
|
|
|
GeneratedBase* GeneratedParameter::appendItem()
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
QString GeneratedParameter::getParameterName() const
|
|
{
|
|
return m_parameterName;
|
|
}
|
|
|
|
void GeneratedParameter::setParameterName(const QString& parameterName)
|
|
{
|
|
m_parameterName = parameterName;
|
|
}
|
|
|
|
GeneratedParameter::DataType GeneratedParameter::getParameterDataType() const
|
|
{
|
|
return m_parameterDataType;
|
|
}
|
|
|
|
void GeneratedParameter::setParameterDataType(const DataType& parameterDataType)
|
|
{
|
|
m_parameterDataType = parameterDataType;
|
|
}
|
|
|
|
QString GeneratedParameter::getParameterDescription() const
|
|
{
|
|
return m_parameterDescription;
|
|
}
|
|
|
|
void GeneratedParameter::setParameterDescription(const QString& parameterDescription)
|
|
{
|
|
m_parameterDescription = parameterDescription;
|
|
}
|
|
|
|
void XFACodeGenerator::generateCode(const QDomDocument& document, QString headerName, QString sourceName)
|
|
{
|
|
QString startMark = "/* START GENERATED CODE */";
|
|
QString endMark = "/* END GENERATED CODE */";
|
|
|
|
loadClasses(document);
|
|
|
|
QFile headerFile(headerName);
|
|
if (headerFile.exists())
|
|
{
|
|
if (headerFile.open(QFile::ReadOnly | QFile::Text))
|
|
{
|
|
QString utfCode = QString::fromUtf8(headerFile.readAll());
|
|
headerFile.close();
|
|
|
|
int startIndex = utfCode.indexOf(startMark, Qt::CaseSensitive) + startMark.length();
|
|
int endIndex = utfCode.indexOf(endMark, Qt::CaseSensitive);
|
|
|
|
QString frontPart = utfCode.left(startIndex);
|
|
QString backPart = utfCode.mid(endIndex);
|
|
QString headerGeneratedCode = generateHeader();
|
|
QString allCode = frontPart + headerGeneratedCode + backPart;
|
|
|
|
headerFile.open(QFile::WriteOnly | QFile::Truncate);
|
|
headerFile.write(allCode.toUtf8());
|
|
headerFile.close();
|
|
}
|
|
}
|
|
|
|
QFile sourceFile(sourceName);
|
|
if (sourceFile.exists())
|
|
{
|
|
if (sourceFile.open(QFile::ReadOnly | QFile::Text))
|
|
{
|
|
QString utfCode = QString::fromUtf8(sourceFile.readAll());
|
|
sourceFile.close();
|
|
|
|
int startIndex = utfCode.indexOf(startMark, Qt::CaseSensitive) + startMark.length();
|
|
int endIndex = utfCode.indexOf(endMark, Qt::CaseSensitive);
|
|
|
|
QString frontPart = utfCode.left(startIndex);
|
|
QString backPart = utfCode.mid(endIndex);
|
|
QString sourceGeneratedCode = generateSource();
|
|
QString allCode = frontPart + sourceGeneratedCode + backPart;
|
|
|
|
sourceFile.open(QFile::WriteOnly | QFile::Truncate);
|
|
sourceFile.write(allCode.toUtf8());
|
|
sourceFile.close();
|
|
}
|
|
}
|
|
}
|
|
|
|
void XFACodeGenerator::loadClasses(const QDomDocument& document)
|
|
{
|
|
QDomElement xfaElement = document.firstChildElement("xfa");
|
|
|
|
if (xfaElement.isNull())
|
|
{
|
|
return;
|
|
}
|
|
|
|
QDomElement element = xfaElement.firstChildElement("template");
|
|
|
|
if (element.isNull())
|
|
{
|
|
return;
|
|
}
|
|
|
|
QDomNodeList childNodes = element.elementsByTagName("class");
|
|
const int size = childNodes.size();
|
|
m_classes.reserve(size);
|
|
for (int i = 0; i < size; ++i)
|
|
{
|
|
QDomNode child = childNodes.item(i);
|
|
|
|
if (!child.isElement())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Class myClass;
|
|
|
|
QDomElement childElement = child.toElement();
|
|
|
|
// Class name
|
|
myClass.className = childElement.attribute("name");
|
|
|
|
QDomElement valueElement = childElement.firstChildElement("value");
|
|
if (!valueElement.isNull())
|
|
{
|
|
QString valueType = valueElement.attribute("type");
|
|
myClass.valueType = createType("node_value", "nodeValue", valueType);
|
|
}
|
|
|
|
// Attributes
|
|
QDomNodeList attributes = childElement.elementsByTagName("property");
|
|
const int attributeCount = attributes.size();
|
|
for (int ai = 0; ai < attributeCount; ++ai)
|
|
{
|
|
QDomElement attributeElement = attributes.item(ai).toElement();
|
|
QString name = attributeElement.attribute("name");
|
|
QString type = attributeElement.attribute("type");
|
|
QString defaultValue = attributeElement.attribute("default");
|
|
QString id = QString("%1_%2").arg(name, type);
|
|
|
|
Attribute attribute;
|
|
attribute.attributeName = name;
|
|
attribute.defaultValue = defaultValue;
|
|
attribute.type = createType(id, name, type);
|
|
|
|
myClass.attributes.emplace_back(std::move(attribute));
|
|
}
|
|
|
|
// Subnodes
|
|
QDomNodeList subnodes = childElement.elementsByTagName("item");
|
|
const int subnodeCount = subnodes.size();
|
|
for (int ai = 0; ai < subnodeCount; ++ai)
|
|
{
|
|
QDomElement subnodeElement = subnodes.item(ai).toElement();
|
|
QString className = subnodeElement.attribute("class");
|
|
QString min = subnodeElement.attribute("min");
|
|
QString max = subnodeElement.attribute("max");
|
|
|
|
Subnode subnode;
|
|
subnode.subnodeName = std::move(className);
|
|
subnode.min = min.toInt();
|
|
subnode.max = (max == "n") ? std::numeric_limits<int>::max() : max.toInt();
|
|
|
|
myClass.subnodes.emplace_back(std::move(subnode));
|
|
}
|
|
|
|
m_classes.emplace_back(std::move(myClass));
|
|
}
|
|
|
|
std::map<QString, QStringList> prerequisites;
|
|
for (const auto& myClass : m_classes)
|
|
{
|
|
QStringList& sl = prerequisites[myClass.className];
|
|
for (const auto& subnode : myClass.subnodes)
|
|
{
|
|
if (subnode.subnodeName != myClass.className)
|
|
{
|
|
sl << subnode.subnodeName;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::vector<Class> sortedClasses;
|
|
while (!m_classes.empty())
|
|
{
|
|
auto it = m_classes.begin();
|
|
for (; it != m_classes.end(); ++it)
|
|
{
|
|
if (prerequisites[it->className].isEmpty())
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (it == m_classes.end())
|
|
{
|
|
break;
|
|
}
|
|
|
|
Class myClass = *it;
|
|
it = m_classes.erase(it);
|
|
|
|
for (auto& prerequisite : prerequisites)
|
|
{
|
|
prerequisite.second.removeAll(myClass.className);
|
|
}
|
|
|
|
sortedClasses.emplace_back(std::move(myClass));
|
|
}
|
|
sortedClasses.insert(sortedClasses.end(), m_classes.begin(), m_classes.end());
|
|
m_classes = std::move(sortedClasses);
|
|
}
|
|
|
|
const XFACodeGenerator::Type* XFACodeGenerator::createType(QString id, QString name, QString type)
|
|
{
|
|
QString simpleType;
|
|
QString adjustedId = id;
|
|
|
|
if (type == "cdata" || type == "pcdata")
|
|
{
|
|
simpleType = "QString";
|
|
adjustedId = "QString";
|
|
}
|
|
else if (type == "0 | 1")
|
|
{
|
|
simpleType = "bool";
|
|
adjustedId = "bool";
|
|
}
|
|
else if (type.contains("measurement"))
|
|
{
|
|
simpleType = "XFA_Measurement";
|
|
adjustedId = "XFA_Measurement";
|
|
}
|
|
else if (type.contains("integer"))
|
|
{
|
|
simpleType = "PDFInteger";
|
|
adjustedId = "PDFInteger";
|
|
}
|
|
else if (type.contains("angle"))
|
|
{
|
|
simpleType = "PDFReal";
|
|
adjustedId = "PDFReal";
|
|
}
|
|
|
|
QString enumValuesString = type;
|
|
|
|
auto it = m_types.find(adjustedId);
|
|
if (it == m_types.end())
|
|
{
|
|
Type typeObject;
|
|
typeObject.id = adjustedId;
|
|
typeObject.typeName = simpleType;
|
|
|
|
if (typeObject.typeName.isEmpty())
|
|
{
|
|
QString typeName = name.toUpper();
|
|
QString finalTypeName = typeName;
|
|
|
|
int i = 1;
|
|
while (m_usedTypes.count(finalTypeName))
|
|
{
|
|
finalTypeName = typeName + QString::number(i++);
|
|
}
|
|
|
|
m_usedTypes.insert(finalTypeName);
|
|
|
|
QString enumValues = enumValuesString.remove(QChar::Space);
|
|
typeObject.enumValues = enumValues.split("|");
|
|
|
|
typeObject.typeName = finalTypeName;
|
|
}
|
|
|
|
it = m_types.insert(std::make_pair(typeObject.id, typeObject)).first;
|
|
}
|
|
|
|
return &it->second;
|
|
}
|
|
|
|
QString XFACodeGenerator::generateSource() const
|
|
{
|
|
QByteArray ba;
|
|
{
|
|
QTextStream stream(&ba, QIODevice::WriteOnly);
|
|
stream.setEncoding(QStringConverter::Utf8);
|
|
stream.setRealNumberPrecision(3);
|
|
stream.setRealNumberNotation(QTextStream::FixedNotation);
|
|
|
|
stream << Qt::endl << Qt::endl;
|
|
stream << "namespace xfa" << Qt::endl;
|
|
stream << "{" << Qt::endl << Qt::endl;
|
|
|
|
// Forward declarations
|
|
for (const Class& myClass : m_classes)
|
|
{
|
|
stream << QString("class XFA_%1;").arg(myClass.className) << Qt::endl;
|
|
}
|
|
|
|
stream << Qt::endl;
|
|
|
|
|
|
stream << "class XFA_AbstractVisitor" << Qt::endl;
|
|
stream << "{" << Qt::endl;
|
|
stream << "public:" << Qt::endl;
|
|
stream << " XFA_AbstractVisitor() = default;" << Qt::endl;
|
|
stream << " virtual ~XFA_AbstractVisitor() = default;" << Qt::endl << Qt::endl;
|
|
for (const Class& myClass : m_classes)
|
|
{
|
|
stream << QString(" virtual void visit(const XFA_%1* node) { Q_UNUSED(node); }").arg(myClass.className) << Qt::endl;
|
|
}
|
|
stream << "};" << Qt::endl;
|
|
stream << Qt::endl;
|
|
|
|
stream << "class XFA_BaseNode : public XFA_AbstractNode" << Qt::endl;
|
|
stream << "{" << Qt::endl;
|
|
stream << "public:" << Qt::endl;
|
|
stream << " using XFA_AbstractNode::parseAttribute;" << Qt::endl;
|
|
|
|
stream << Qt::endl;
|
|
|
|
for (const auto& typeItem : m_types)
|
|
{
|
|
const Type& type = typeItem.second;
|
|
|
|
if (type.enumValues.isEmpty())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
stream << QString(" enum class %1").arg(type.typeName) << Qt::endl;
|
|
stream << " {" << Qt::endl;
|
|
for (const QString& enumValue : type.enumValues)
|
|
{
|
|
stream << " " << getEnumValueName(enumValue) << "," << Qt::endl;
|
|
}
|
|
stream << " };" << Qt::endl << Qt::endl;
|
|
}
|
|
|
|
for (const auto& typeItem : m_types)
|
|
{
|
|
const Type& type = typeItem.second;
|
|
|
|
if (type.enumValues.isEmpty())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
stream << QString(" static void parseAttribute(const QDomElement& element, QString attributeFieldName, XFA_Attribute<%1>& attribute, QString defaultValue)").arg(type.typeName) << Qt::endl;
|
|
stream << QString(" {") << Qt::endl;
|
|
stream << QString(" constexpr std::array enumValues = {") << Qt::endl;
|
|
for (const QString& enumValue : type.enumValues)
|
|
{
|
|
QString adjustedEnumValue = enumValue;
|
|
adjustedEnumValue.replace("\\", "\\\\");
|
|
stream << QString(" std::make_pair(%1::%2, \"%3\"),").arg(type.typeName, getEnumValueName(enumValue), adjustedEnumValue) << Qt::endl;
|
|
}
|
|
stream << QString(" };") << Qt::endl;
|
|
stream << QString(" parseEnumAttribute(element, attributeFieldName, attribute, defaultValue, enumValues);") << Qt::endl;
|
|
stream << QString(" }") << Qt::endl << Qt::endl;
|
|
}
|
|
|
|
stream << "};" << Qt::endl << Qt::endl;
|
|
|
|
for (const Class& myClass : m_classes)
|
|
{
|
|
stream << QString("class XFA_%1 : public XFA_BaseNode").arg(myClass.className) << Qt::endl;
|
|
stream << "{" << Qt::endl;
|
|
stream << "public:" << Qt::endl;
|
|
|
|
QStringList attributeGetters;
|
|
QStringList attributeDeclarations;
|
|
for (const Attribute& attribute : myClass.attributes)
|
|
{
|
|
QString attributeFieldName = QString("m_%1").arg(attribute.attributeName);
|
|
QString attributeGetterName = attribute.attributeName;
|
|
attributeGetterName[0] = attributeGetterName.front().toUpper();
|
|
QString attributeDeclaration = QString(" XFA_Attribute<%1> %2;").arg(attribute.type->typeName, attributeFieldName);
|
|
QString attributeGetter = QString(" %1 get%2() const { return %3.getValueOrDefault(); }").arg(attribute.type->typeName, attributeGetterName, attributeFieldName);
|
|
attributeDeclarations << attributeDeclaration;
|
|
attributeGetters << attributeGetter;
|
|
}
|
|
|
|
stream << Qt::endl;
|
|
|
|
QStringList subnodeGetters;
|
|
QStringList subnodeDeclarations;
|
|
for (const Subnode& subnode : myClass.subnodes)
|
|
{
|
|
if (subnode.max == 1)
|
|
{
|
|
QString subnodeFieldName = QString("m_%1").arg(subnode.subnodeName);
|
|
QString subnodeTypeName = QString("XFA_%1").arg(subnode.subnodeName);
|
|
QString subnodeGetterName = subnode.subnodeName;
|
|
subnodeGetterName[0] = subnodeGetterName.front().toUpper();
|
|
QString subnodeDeclaration = QString(" XFA_Node<%1> %2;").arg(subnodeTypeName, subnodeFieldName);
|
|
QString subnodeGetter = QString(" const %1* get%2() const { return %3.getValue(); }").arg(subnodeTypeName, subnodeGetterName, subnodeFieldName);
|
|
subnodeDeclarations << subnodeDeclaration;
|
|
subnodeGetters << subnodeGetter;
|
|
}
|
|
else
|
|
{
|
|
QString subnodeFieldName = QString("m_%1").arg(subnode.subnodeName);
|
|
QString subnodeTypeName = QString("std::vector<XFA_Node<XFA_%1>>").arg(subnode.subnodeName);
|
|
QString subnodeGetterName = subnode.subnodeName;
|
|
subnodeGetterName[0] = subnodeGetterName.front().toUpper();
|
|
QString subnodeDeclaration = QString(" %1 %2;").arg(subnodeTypeName, subnodeFieldName);
|
|
QString subnodeGetter = QString(" const %1& get%2() const { return %3; }").arg(subnodeTypeName, subnodeGetterName, subnodeFieldName);
|
|
subnodeDeclarations << subnodeDeclaration;
|
|
subnodeGetters << subnodeGetter;
|
|
}
|
|
}
|
|
|
|
for (const QString& getter : attributeGetters)
|
|
{
|
|
stream << getter << Qt::endl;
|
|
}
|
|
|
|
stream << Qt::endl;
|
|
|
|
for (const QString& getter : subnodeGetters)
|
|
{
|
|
stream << getter << Qt::endl;
|
|
}
|
|
|
|
stream << Qt::endl;
|
|
|
|
if (myClass.valueType)
|
|
{
|
|
stream << QString(" const %1* getNodeValue() const { return m_nodeValue.getValue(); }").arg(myClass.valueType->typeName) << Qt::endl << Qt::endl;
|
|
}
|
|
|
|
stream << QString(" virtual void accept(XFA_AbstractVisitor* visitor) const override { visitor->visit(this); }") << Qt::endl << Qt::endl;
|
|
|
|
stream << QString(" static std::optional<XFA_%1> parse(const QDomElement& element);").arg(myClass.className) << Qt::endl;
|
|
|
|
stream << Qt::endl;
|
|
|
|
stream << "private:" << Qt::endl;
|
|
stream << " /* properties */" << Qt::endl;
|
|
|
|
for (const QString& getter : attributeDeclarations)
|
|
{
|
|
stream << getter << Qt::endl;
|
|
}
|
|
|
|
stream << Qt::endl;
|
|
|
|
stream << " /* subnodes */" << Qt::endl;
|
|
|
|
for (const QString& getter : subnodeDeclarations)
|
|
{
|
|
stream << getter << Qt::endl;
|
|
}
|
|
|
|
if (myClass.valueType)
|
|
{
|
|
stream << Qt::endl;
|
|
stream << QString(" XFA_Value<%1> m_nodeValue;").arg(myClass.valueType->typeName) << Qt::endl;
|
|
}
|
|
|
|
stream << "};" << Qt::endl << Qt::endl;
|
|
|
|
// Class loader
|
|
stream << QString("std::optional<XFA_%1> XFA_%1::parse(const QDomElement& element)").arg(myClass.className) << Qt::endl;
|
|
stream << "{" << Qt::endl;
|
|
stream << " if (element.isNull())" << Qt::endl << " {" << Qt::endl << " return std::nullopt;" << Qt::endl << " }" << Qt::endl << Qt::endl;
|
|
stream << QString(" XFA_%1 myClass;").arg(myClass.className) << Qt::endl << Qt::endl;
|
|
|
|
// Load attributes
|
|
stream << " // load attributes" << Qt::endl;
|
|
for (const Attribute& attribute : myClass.attributes)
|
|
{
|
|
QString attributeFieldName = QString("m_%1").arg(attribute.attributeName);
|
|
QString adjustedDefaultValue = attribute.defaultValue;
|
|
adjustedDefaultValue.replace("\\", "\\\\");
|
|
stream << QString(" parseAttribute(element, \"%1\", myClass.%2, \"%3\");").arg(attribute.attributeName, attributeFieldName, adjustedDefaultValue) << Qt::endl;
|
|
}
|
|
|
|
stream << Qt::endl;
|
|
|
|
// Load subitems
|
|
stream << " // load items" << Qt::endl;
|
|
for (const Subnode& subnode : myClass.subnodes)
|
|
{
|
|
QString subnodeFieldName = QString("m_%1").arg(subnode.subnodeName);
|
|
stream << QString(" parseItem(element, \"%1\", myClass.%2);").arg(subnode.subnodeName, subnodeFieldName) << Qt::endl;
|
|
}
|
|
|
|
// Node value
|
|
if (myClass.valueType)
|
|
{
|
|
stream << Qt::endl;
|
|
stream << " // load node value" << Qt::endl;
|
|
stream << QString(" parseValue(element, myClass.m_nodeValue);") << Qt::endl << Qt::endl;
|
|
}
|
|
|
|
stream << " myClass.setOrderFromElement(element);" << Qt::endl;
|
|
stream << " return myClass;" << Qt::endl;
|
|
stream << "}" << Qt::endl;
|
|
|
|
stream << Qt::endl << Qt::endl;
|
|
}
|
|
|
|
stream << "} // namespace xfa" << Qt::endl;
|
|
stream << Qt::endl << Qt::endl;
|
|
}
|
|
|
|
return QString::fromUtf8(ba);
|
|
}
|
|
|
|
QString XFACodeGenerator::getEnumValueName(QString enumName) const
|
|
{
|
|
if (!enumName.isEmpty())
|
|
{
|
|
enumName[0] = enumName.front().toUpper();
|
|
|
|
if (enumName.front().isDigit())
|
|
{
|
|
enumName.push_front("_");
|
|
}
|
|
|
|
enumName.replace("-", "_");
|
|
enumName.replace('\\', "Backslash");
|
|
enumName.replace('/', "Slash");
|
|
enumName.replace('.', "_");
|
|
}
|
|
|
|
return enumName;
|
|
}
|
|
|
|
QString XFACodeGenerator::generateHeader() const
|
|
{
|
|
QByteArray ba;
|
|
{
|
|
QTextStream stream(&ba, QIODevice::WriteOnly);
|
|
stream.setEncoding(QStringConverter::Utf8);
|
|
stream.setRealNumberPrecision(3);
|
|
stream.setRealNumberNotation(QTextStream::FixedNotation);
|
|
|
|
stream << Qt::endl << Qt::endl;
|
|
stream << "namespace xfa" << Qt::endl;
|
|
stream << "{" << Qt::endl;
|
|
|
|
|
|
stream << "} // namespace xfa" << Qt::endl;
|
|
stream << Qt::endl << Qt::endl;
|
|
}
|
|
|
|
return QString::fromUtf8(ba);
|
|
}
|
|
|
|
}
|