mirrors/LimeReport
0
0
Fork 0
mirror of https://github.com/fralx/LimeReport.git synced 2025-11-25 08:28:06 +03:00
Code Activity

Define code style and format all source file using clang-format-14

Browse Source 
except those placed in 3rdparty directories.
This commit is contained in:
Андрей Лухнов
2024-09-04 17:31:16 +03:00
parent c5b9ac265d
commit 0fca7169d3
285 changed files with 19120 additions and 17875 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
limereport/serializators/lrserializatorintf.h
View File

@@ -32,19 +32,17 @@
#include <QObject>
namespace LimeReport {
class SerializatorIntf
{
class SerializatorIntf {
public:
virtual QVariant loadValue() = 0;
virtual void save(const QVariant& value,QString name) = 0;
virtual ~SerializatorIntf(){}
virtual void save(const QVariant& value, QString name) = 0;
virtual ~SerializatorIntf() { }
};
class CryptedSerializator : public virtual SerializatorIntf
{
class CryptedSerializator: public virtual SerializatorIntf {
public:
virtual void setPassPhrase(const QString& passPhrase) = 0;
};
}
} // namespace LimeReport
#endif // LRSERIALIZATORINTF_H

19
limereport/serializators/lrstorageintf.h
View File

@@ -31,33 +31,32 @@
#define LRSTORAGEINTF_H
#include "lrglobal.h"
#include <QSharedPointer>
class QString;
class QObject;
namespace LimeReport{
namespace LimeReport {
class LIMEREPORT_EXPORT ObjectLoadingStateIntf{
class LIMEREPORT_EXPORT ObjectLoadingStateIntf {
public:
virtual bool isLoading() = 0;
virtual void objectLoadStarted() = 0;
virtual void objectLoadFinished() = 0;
};
class LIMEREPORT_EXPORT ItemsWriterIntf
{
class LIMEREPORT_EXPORT ItemsWriterIntf {
public:
virtual void putItem(QObject* item) = 0;
virtual bool saveToFile(QString fileName) = 0;
virtual QString saveToString() = 0;
virtual QByteArray saveToByteArray() = 0;
virtual void setPassPhrase(const QString& passPhrase) = 0;
virtual ~ItemsWriterIntf(){}
virtual ~ItemsWriterIntf() { }
};
class LIMEREPORT_EXPORT ItemsReaderIntf
{
class LIMEREPORT_EXPORT ItemsReaderIntf {
public:
typedef QSharedPointer<ItemsReaderIntf> Ptr;
virtual bool first() = 0;
@@ -65,12 +64,12 @@ public:
virtual bool prior() = 0;
virtual QString itemType() = 0;
virtual QString itemClassName() = 0;
virtual bool readItem(QObject *item) = 0;
virtual bool readItem(QObject* item) = 0;
virtual int firstLevelItemsCount() = 0;
virtual QString lastError() = 0;
virtual void setPassPhrase(const QString& passPhrase) = 0;
virtual ~ItemsReaderIntf(){}
virtual ~ItemsReaderIntf() { }
};
}
} // namespace LimeReport
#endif // LRSTORAGEINTF_H

311
limereport/serializators/lrxmlbasetypesserializators.cpp
View File

@@ -28,91 +28,129 @@
* GNU General Public License for more details. *
****************************************************************************/
#include "lrxmlbasetypesserializators.h"
#include "serializators/lrxmlserializatorsfactory.h"
#include "lrsimplecrypt.h"
#include "serializators/lrxmlserializatorsfactory.h"
#include <QColor>
#include <QFont>
#include <QImage>
#include <QColor>
namespace{
namespace {
LimeReport::SerializatorIntf * createIntSerializator(QDomDocument *doc, QDomElement *node){
return new LimeReport::XmlIntSerializator(doc,node);
}
LimeReport::SerializatorIntf * createQRealSerializator(QDomDocument *doc, QDomElement *node){
return new LimeReport::XmlQRealSerializator(doc,node);
}
LimeReport::SerializatorIntf * createQStringSerializator(QDomDocument *doc, QDomElement *node){
return new LimeReport::XmlQStringSerializator(doc,node);
}
LimeReport::SerializatorIntf * createEnumAndFlagsSerializator(QDomDocument *doc, QDomElement *node){
return new LimeReport::XmlEnumAndFlagsSerializator(doc,node);
}
LimeReport::SerializatorIntf * createBoolSerializator(QDomDocument *doc, QDomElement *node){
return new LimeReport::XmlBoolSerializator(doc,node);
}
LimeReport::SerializatorIntf * createFontSerializator(QDomDocument *doc, QDomElement *node){
return new LimeReport::XmlFontSerializator(doc,node);
}
LimeReport::SerializatorIntf * createQSizeFSerializator(QDomDocument *doc, QDomElement *node){
return new LimeReport::XmlQSizeFSerializator(doc,node);
}
LimeReport::SerializatorIntf * createQImageSerializator(QDomDocument *doc, QDomElement *node){
return new LimeReport::XmlQImageSerializator(doc,node);
}
LimeReport::SerializatorIntf * createQColorSerializator(QDomDocument *doc, QDomElement *node){
return new LimeReport::XmlColorSerializator(doc,node);
}
LimeReport::SerializatorIntf* createQByteArraySerializator(QDomDocument *doc, QDomElement *node){
return new LimeReport::XmlQByteArraySerializator(doc,node);
}
LimeReport::SerializatorIntf* createQVariantSerializator(QDomDocument *doc, QDomElement *node){
return new LimeReport::XmlQVariantSerializator(doc,node);
}
bool VARIABLE_IS_NOT_USED registredQString = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("QString", createQStringSerializator);
bool VARIABLE_IS_NOT_USED registredInt = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("int", createIntSerializator);
bool VARIABLE_IS_NOT_USED registredEnumAndFlags = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("enumAndFlags",createEnumAndFlagsSerializator);
bool VARIABLE_IS_NOT_USED registredBool = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("bool", createBoolSerializator);
bool VARIABLE_IS_NOT_USED registredQFont = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("QFont", createFontSerializator);
bool VARIABLE_IS_NOT_USED registredQSizeF = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("QSizeF", createQSizeFSerializator);
bool VARIABLE_IS_NOT_USED registredQImage = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("QImage", createQImageSerializator);
bool VARIABLE_IS_NOT_USED registredQReal = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("qreal", createQRealSerializator);
bool VARIABLE_IS_NOT_USED registerDouble = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("double", createQRealSerializator);
bool VARIABLE_IS_NOT_USED registerQColor = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("QColor", createQColorSerializator);
bool VARIABLE_IS_NOT_USED registerQByteArray = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("QByteArray", createQByteArraySerializator);
bool VARIABLE_IS_NOT_USED registerQVariant = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("QVariant", createQVariantSerializator);
}
namespace LimeReport{
void XmlBaseSerializator::saveBool(QDomElement node,QString name, bool value)
LimeReport::SerializatorIntf* createIntSerializator(QDomDocument* doc, QDomElement* node)
{
if (value) node.setAttribute(name,1);
else node.setAttribute(name,0);
return new LimeReport::XmlIntSerializator(doc, node);
}
void XmlQStringSerializator::save(const QVariant &value, QString name)
LimeReport::SerializatorIntf* createQRealSerializator(QDomDocument* doc, QDomElement* node)
{
return new LimeReport::XmlQRealSerializator(doc, node);
}
LimeReport::SerializatorIntf* createQStringSerializator(QDomDocument* doc, QDomElement* node)
{
return new LimeReport::XmlQStringSerializator(doc, node);
}
LimeReport::SerializatorIntf* createEnumAndFlagsSerializator(QDomDocument* doc, QDomElement* node)
{
return new LimeReport::XmlEnumAndFlagsSerializator(doc, node);
}
LimeReport::SerializatorIntf* createBoolSerializator(QDomDocument* doc, QDomElement* node)
{
return new LimeReport::XmlBoolSerializator(doc, node);
}
LimeReport::SerializatorIntf* createFontSerializator(QDomDocument* doc, QDomElement* node)
{
return new LimeReport::XmlFontSerializator(doc, node);
}
LimeReport::SerializatorIntf* createQSizeFSerializator(QDomDocument* doc, QDomElement* node)
{
return new LimeReport::XmlQSizeFSerializator(doc, node);
}
LimeReport::SerializatorIntf* createQImageSerializator(QDomDocument* doc, QDomElement* node)
{
return new LimeReport::XmlQImageSerializator(doc, node);
}
LimeReport::SerializatorIntf* createQColorSerializator(QDomDocument* doc, QDomElement* node)
{
return new LimeReport::XmlColorSerializator(doc, node);
}
LimeReport::SerializatorIntf* createQByteArraySerializator(QDomDocument* doc, QDomElement* node)
{
return new LimeReport::XmlQByteArraySerializator(doc, node);
}
LimeReport::SerializatorIntf* createQVariantSerializator(QDomDocument* doc, QDomElement* node)
{
return new LimeReport::XmlQVariantSerializator(doc, node);
}
bool VARIABLE_IS_NOT_USED registredQString
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator(
"QString", createQStringSerializator);
bool VARIABLE_IS_NOT_USED registredInt
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("int",
createIntSerializator);
bool VARIABLE_IS_NOT_USED registredEnumAndFlags
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator(
"enumAndFlags", createEnumAndFlagsSerializator);
bool VARIABLE_IS_NOT_USED registredBool
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator(
"bool", createBoolSerializator);
bool VARIABLE_IS_NOT_USED registredQFont
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator(
"QFont", createFontSerializator);
bool VARIABLE_IS_NOT_USED registredQSizeF
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator(
"QSizeF", createQSizeFSerializator);
bool VARIABLE_IS_NOT_USED registredQImage
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator(
"QImage", createQImageSerializator);
bool VARIABLE_IS_NOT_USED registredQReal
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator(
"qreal", createQRealSerializator);
bool VARIABLE_IS_NOT_USED registerDouble
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator(
"double", createQRealSerializator);
bool VARIABLE_IS_NOT_USED registerQColor
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator(
"QColor", createQColorSerializator);
bool VARIABLE_IS_NOT_USED registerQByteArray
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator(
"QByteArray", createQByteArraySerializator);
bool VARIABLE_IS_NOT_USED registerQVariant
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator(
"QVariant", createQVariantSerializator);
} // namespace
namespace LimeReport {
void XmlBaseSerializator::saveBool(QDomElement node, QString name, bool value)
{
if (value)
node.setAttribute(name, 1);
else
node.setAttribute(name, 0);
}
void XmlQStringSerializator::save(const QVariant& value, QString name)
{
QDomElement _node = doc()->createElement(name);
_node.setAttribute("Type","QString");
if (name.compare("password")==0){
_node.setAttribute("Type", "QString");
if (name.compare("password") == 0) {
Chipper chipper(passPhrase());
QByteArray ba = chipper.cryptString(value.toString());
//ba.append();
_node.setAttribute("Value",QString(ba.toBase64()));
// ba.append();
_node.setAttribute("Value", QString(ba.toBase64()));
} else {
_node.appendChild(doc()->createTextNode(value.toString()));
}
@@ -121,7 +159,7 @@ void XmlQStringSerializator::save(const QVariant &value, QString name)
QVariant XmlQStringSerializator::loadValue()
{
if (node()->tagName().compare("password")==0){
if (node()->tagName().compare("password") == 0) {
QByteArray ba;
Chipper chipper(passPhrase());
ba.append(node()->attribute("Value").toLatin1());
@@ -130,62 +168,54 @@ QVariant XmlQStringSerializator::loadValue()
return node()->text();
}
void XmlIntSerializator::save(const QVariant &value, QString name)
void XmlIntSerializator::save(const QVariant& value, QString name)
{
QDomElement _node = doc()->createElement(name);
_node.setAttribute("Type","int");
_node.setAttribute("Value",value.toInt());
_node.setAttribute("Type", "int");
_node.setAttribute("Value", value.toInt());
node()->appendChild(_node);
}
QVariant XmlIntSerializator::loadValue()
{
return node()->attribute("Value").toInt();
}
QVariant XmlIntSerializator::loadValue() { return node()->attribute("Value").toInt(); }
void XmlEnumAndFlagsSerializator::save(const QVariant &value, QString name)
void XmlEnumAndFlagsSerializator::save(const QVariant& value, QString name)
{
QDomElement _node = doc()->createElement(name);
_node.setAttribute("Type","enumAndFlags");
_node.setAttribute("Value",value.toInt());
_node.setAttribute("Type", "enumAndFlags");
_node.setAttribute("Value", value.toInt());
node()->appendChild(_node);
}
QVariant XmlEnumAndFlagsSerializator::loadValue()
{
return node()->attribute("Value").toInt();
}
QVariant XmlEnumAndFlagsSerializator::loadValue() { return node()->attribute("Value").toInt(); }
void XmlBoolSerializator::save(const QVariant &value, QString name)
void XmlBoolSerializator::save(const QVariant& value, QString name)
{
QDomElement _node = doc()->createElement(name);
_node.setAttribute("Type","bool");
_node.setAttribute("Type", "bool");
if (value.toBool())
_node.setAttribute("Value",1);
else _node.setAttribute("Value",0);
_node.setAttribute("Value", 1);
else
_node.setAttribute("Value", 0);
node()->appendChild(_node);
}
QVariant XmlBoolSerializator::loadValue()
{
return node()->attribute("Value").toInt();
}
QVariant XmlBoolSerializator::loadValue() { return node()->attribute("Value").toInt(); }
void XmlFontSerializator::save(const QVariant &value, QString name)
void XmlFontSerializator::save(const QVariant& value, QString name)
{
QFont font = value.value<QFont>();
QDomElement _node = doc()->createElement(name);
_node.setAttribute("Type","QFont");
_node.setAttribute("family",font.family());
_node.setAttribute("pointSize",font.pointSize());
//#if QT_VERSION>0x040800
// _node.setAttribute("stylename",font.styleName());
//#endif
_node.setAttribute("weight",font.weight());
//saveBool(_node,"bold",font.bold());
saveBool(_node,"italic",font.italic());
saveBool(_node,"underline",font.underline());
_node.setAttribute("Type", "QFont");
_node.setAttribute("family", font.family());
_node.setAttribute("pointSize", font.pointSize());
//#if QT_VERSION>0x040800
// _node.setAttribute("stylename",font.styleName());
//#endif
_node.setAttribute("weight", font.weight());
// saveBool(_node,"bold",font.bold());
saveBool(_node, "italic", font.italic());
saveBool(_node, "underline", font.underline());
node()->appendChild(_node);
}
@@ -194,25 +224,25 @@ QVariant XmlFontSerializator::loadValue()
QFont font;
font.setFamily(node()->attribute("family"));
font.setPointSize(node()->attribute("pointSize").toInt());
//#if QT_VERSION>0x040800
// font.setStyleName(node()->attribute("stylename"));
//#endif
//#if QT_VERSION>0x040800
// font.setStyleName(node()->attribute("stylename"));
//#endif
if (node()->attribute("weight").toInt() > 0)
font.setWeight(static_cast<QFont::Weight>(node()->attribute("weight").toInt()));
if (!node()->attribute("bold").isEmpty())
font.setBold(node()->attribute("bold").toInt());
font.setBold(node()->attribute("bold").toInt());
font.setItalic(node()->attribute("italic").toInt());
font.setUnderline(node()->attribute("underline").toInt());
return font;
}
void XmlQSizeFSerializator::save(const QVariant &value, QString name)
void XmlQSizeFSerializator::save(const QVariant& value, QString name)
{
QSizeF size = value.toSizeF();
QDomElement _node = doc()->createElement(name);
_node.setAttribute("Type","QSizeF");
_node.setAttribute("width",QString::number(size.width()));
_node.setAttribute("height",QString::number(size.height()));
_node.setAttribute("Type", "QSizeF");
_node.setAttribute("width", QString::number(size.width()));
_node.setAttribute("height", QString::number(size.height()));
node()->appendChild(_node);
}
@@ -224,15 +254,15 @@ QVariant XmlQSizeFSerializator::loadValue()
return size;
}
void XmlQImageSerializator::save(const QVariant &value, QString name)
void XmlQImageSerializator::save(const QVariant& value, QString name)
{
QImage image=value.value<QImage>();
QImage image = value.value<QImage>();
QByteArray ba;
QBuffer buff(&ba);
buff.open(QIODevice::WriteOnly);
image.save(&buff,"PNG");
image.save(&buff, "PNG");
QDomElement _node = doc()->createElement(name);
_node.setAttribute("Type","QImage");
_node.setAttribute("Type", "QImage");
_node.appendChild(doc()->createTextNode(ba.toHex()));
node()->appendChild(_node);
}
@@ -240,41 +270,35 @@ void XmlQImageSerializator::save(const QVariant &value, QString name)
QVariant XmlQImageSerializator::loadValue()
{
QImage img;
img.loadFromData(QByteArray::fromHex(node()->text().toLatin1()),"PNG");
img.loadFromData(QByteArray::fromHex(node()->text().toLatin1()), "PNG");
return img;
}
void XmlQRealSerializator::save(const QVariant &value, QString name)
void XmlQRealSerializator::save(const QVariant& value, QString name)
{
QDomElement _node = doc()->createElement(name);
_node.setAttribute("Type","qreal");
_node.setAttribute("Value",QString::number(value.toDouble()));
_node.setAttribute("Type", "qreal");
_node.setAttribute("Value", QString::number(value.toDouble()));
node()->appendChild(_node);
}
QVariant XmlQRealSerializator::loadValue()
{
return node()->attribute("Value").toDouble();
}
QVariant XmlQRealSerializator::loadValue() { return node()->attribute("Value").toDouble(); }
void XmlColorSerializator::save(const QVariant &value, QString name)
void XmlColorSerializator::save(const QVariant& value, QString name)
{
QDomElement _node = doc()->createElement(name);
_node.setAttribute("Type","QColor");
_node.setAttribute("Value",value.value<QColor>().name());
_node.setAttribute("Type", "QColor");
_node.setAttribute("Value", value.value<QColor>().name());
node()->appendChild(_node);
}
QVariant XmlColorSerializator::loadValue()
{
return QColor(node()->attribute("Value"));
}
QVariant XmlColorSerializator::loadValue() { return QColor(node()->attribute("Value")); }
void XmlQByteArraySerializator::save(const QVariant &value, QString name)
void XmlQByteArraySerializator::save(const QVariant& value, QString name)
{
QDomElement _node = doc()->createElement(name);
_node.setAttribute("Type","QByteArray");
_node.setAttribute("Value",QString(value.toByteArray().toBase64()));
_node.setAttribute("Type", "QByteArray");
_node.setAttribute("Value", QString(value.toByteArray().toBase64()));
node()->appendChild(_node);
}
@@ -285,11 +309,11 @@ QVariant XmlQByteArraySerializator::loadValue()
return QByteArray::fromBase64(ba);
}
void XmlQVariantSerializator::save(const QVariant &value, QString name)
void XmlQVariantSerializator::save(const QVariant& value, QString name)
{
QDomElement _node = doc()->createElement(name);
_node.setAttribute("Type","QVariant");
_node.setAttribute("Value",QString(value.toByteArray().toBase64()));
_node.setAttribute("Type", "QVariant");
_node.setAttribute("Value", QString(value.toByteArray().toBase64()));
node()->appendChild(_node);
}
@@ -300,9 +324,4 @@ QVariant XmlQVariantSerializator::loadValue()
return QByteArray::fromBase64(ba);
}
}
} // namespace LimeReport

160
limereport/serializators/lrxmlbasetypesserializators.h
View File

@@ -31,131 +31,149 @@
#define LRXMLBASETYPESSERIALIZATORS_H
#include "lrserializatorintf.h"
#include <QtXml>
#include <QDebug>
#include <QtXml>
namespace LimeReport{
namespace LimeReport {
class XmlBaseSerializator : public virtual SerializatorIntf{
class XmlBaseSerializator: public virtual SerializatorIntf {
public:
XmlBaseSerializator(QDomDocument *doc, QDomElement *node):m_doc(doc),m_node(node){}
XmlBaseSerializator(QDomDocument* doc, QDomElement* node): m_doc(doc), m_node(node) { }
protected:
QDomDocument* doc() {return m_doc;}
QDomElement* node() {if (!m_node) qDebug()<<QLatin1String("Warning node is null"); return m_node;}
QDomDocument* doc() { return m_doc; }
QDomElement* node()
{
if (!m_node)
qDebug() << QLatin1String("Warning node is null");
return m_node;
}
void saveBool(QDomElement node, QString name, bool value);
private:
QDomDocument *m_doc;
QDomElement *m_node;
QDomDocument* m_doc;
QDomElement* m_node;
};
class XmlCryptedSerializator : public XmlBaseSerializator, public virtual CryptedSerializator{
class XmlCryptedSerializator: public XmlBaseSerializator, public virtual CryptedSerializator {
public:
XmlCryptedSerializator(QDomDocument *doc, QDomElement *node)
:XmlBaseSerializator(doc, node){}
virtual void setPassPhrase(const QString& passPhrase) {m_passPhrase = passPhrase;}
XmlCryptedSerializator(QDomDocument* doc, QDomElement* node): XmlBaseSerializator(doc, node) { }
virtual void setPassPhrase(const QString& passPhrase) { m_passPhrase = passPhrase; }
protected:
QString passPhrase(){ return m_passPhrase;}
QString passPhrase() { return m_passPhrase; }
private:
QString m_passPhrase;
};
class XmlQStringSerializator : public XmlCryptedSerializator
{
class XmlQStringSerializator: public XmlCryptedSerializator {
public:
XmlQStringSerializator(QDomDocument *doc, QDomElement *node):XmlCryptedSerializator(doc,node){}
XmlQStringSerializator(QDomDocument* doc, QDomElement* node): XmlCryptedSerializator(doc, node)
{
}
private:
virtual void save(const QVariant &value,QString name);
virtual void save(const QVariant& value, QString name);
virtual QVariant loadValue();
};
class XmlIntSerializator : public XmlBaseSerializator
{
class XmlIntSerializator: public XmlBaseSerializator {
public:
XmlIntSerializator(QDomDocument *doc, QDomElement *node):XmlBaseSerializator(doc,node){}
XmlIntSerializator(QDomDocument* doc, QDomElement* node): XmlBaseSerializator(doc, node) { }
private:
virtual void save(const QVariant &value,QString name);
virtual void save(const QVariant& value, QString name);
virtual QVariant loadValue();
};
class XmlQRealSerializator : public XmlBaseSerializator
{
class XmlQRealSerializator: public XmlBaseSerializator {
public:
XmlQRealSerializator(QDomDocument *doc, QDomElement *node):XmlBaseSerializator(doc,node){}
XmlQRealSerializator(QDomDocument* doc, QDomElement* node): XmlBaseSerializator(doc, node) { }
private:
virtual void save(const QVariant &value,QString name);
virtual void save(const QVariant& value, QString name);
virtual QVariant loadValue();
};
class XmlEnumAndFlagsSerializator : public XmlBaseSerializator
{
class XmlEnumAndFlagsSerializator: public XmlBaseSerializator {
public:
XmlEnumAndFlagsSerializator(QDomDocument *doc, QDomElement *node):XmlBaseSerializator(doc,node){}
XmlEnumAndFlagsSerializator(QDomDocument* doc, QDomElement* node):
XmlBaseSerializator(doc, node)
{
}
private:
virtual void save(const QVariant &value, QString name);
virtual void save(const QVariant& value, QString name);
virtual QVariant loadValue();
};
class XmlBoolSerializator : public XmlBaseSerializator
{
class XmlBoolSerializator: public XmlBaseSerializator {
public:
XmlBoolSerializator(QDomDocument *doc, QDomElement *node):XmlBaseSerializator(doc,node){}
XmlBoolSerializator(QDomDocument* doc, QDomElement* node): XmlBaseSerializator(doc, node) { }
private:
virtual void save(const QVariant &value, QString name);
virtual void save(const QVariant& value, QString name);
virtual QVariant loadValue();
};
class XmlFontSerializator : public XmlBaseSerializator
{
class XmlFontSerializator: public XmlBaseSerializator {
public:
XmlFontSerializator(QDomDocument *doc, QDomElement *node):XmlBaseSerializator(doc,node){}
private:
virtual void save(const QVariant &value, QString name);
virtual QVariant loadValue();
};
XmlFontSerializator(QDomDocument* doc, QDomElement* node): XmlBaseSerializator(doc, node) { }
class XmlQSizeFSerializator : public XmlBaseSerializator
{
public:
XmlQSizeFSerializator(QDomDocument *doc, QDomElement *node):XmlBaseSerializator(doc,node){}
private:
virtual void save(const QVariant &value, QString name);
virtual QVariant loadValue();
};
class XmlColorSerializator : public XmlBaseSerializator
{
public:
XmlColorSerializator(QDomDocument *doc, QDomElement *node):XmlBaseSerializator(doc,node){}
private:
virtual void save(const QVariant &value, QString name);
virtual QVariant loadValue();
};
class XmlQImageSerializator : public XmlBaseSerializator
{
public:
XmlQImageSerializator(QDomDocument *doc, QDomElement *node):XmlBaseSerializator(doc,node){}
private:
virtual void save(const QVariant &value, QString name);
virtual void save(const QVariant& value, QString name);
virtual QVariant loadValue();
};
class XmlQByteArraySerializator : public XmlBaseSerializator{
class XmlQSizeFSerializator: public XmlBaseSerializator {
public:
XmlQByteArraySerializator(QDomDocument *doc, QDomElement *node):XmlBaseSerializator(doc,node){}
XmlQSizeFSerializator(QDomDocument* doc, QDomElement* node): XmlBaseSerializator(doc, node) { }
private:
virtual void save(const QVariant &value, QString name);
virtual void save(const QVariant& value, QString name);
virtual QVariant loadValue();
};
class XmlQVariantSerializator : public XmlBaseSerializator
{
class XmlColorSerializator: public XmlBaseSerializator {
public:
XmlQVariantSerializator(QDomDocument *doc, QDomElement *node):XmlBaseSerializator(doc,node){}
XmlColorSerializator(QDomDocument* doc, QDomElement* node): XmlBaseSerializator(doc, node) { }
private:
virtual void save(const QVariant &value, QString name);
virtual void save(const QVariant& value, QString name);
virtual QVariant loadValue();
};
}
class XmlQImageSerializator: public XmlBaseSerializator {
public:
XmlQImageSerializator(QDomDocument* doc, QDomElement* node): XmlBaseSerializator(doc, node) { }
private:
virtual void save(const QVariant& value, QString name);
virtual QVariant loadValue();
};
class XmlQByteArraySerializator: public XmlBaseSerializator {
public:
XmlQByteArraySerializator(QDomDocument* doc, QDomElement* node): XmlBaseSerializator(doc, node)
{
}
private:
virtual void save(const QVariant& value, QString name);
virtual QVariant loadValue();
};
class XmlQVariantSerializator: public XmlBaseSerializator {
public:
XmlQVariantSerializator(QDomDocument* doc, QDomElement* node):
XmlBaseSerializator(doc, node) { }
private:
virtual void save(const QVariant& value, QString name);
virtual QVariant loadValue();
};
} // namespace LimeReport
#endif // LRXMLBASETYPESSERIALIZATORS_H

71
limereport/serializators/lrxmlqrectserializator.cpp
View File

@@ -28,76 +28,75 @@
* GNU General Public License for more details. *
****************************************************************************/
#include "lrxmlqrectserializator.h"
#include "lrserializatorintf.h"
#include "lrxmlserializatorsfactory.h"
#include <QRect>
#include <QRectF>
namespace{
namespace {
LimeReport::SerializatorIntf * createQRectSerializator(QDomDocument *doc, QDomElement *node){
return new LimeReport::XMLQRectSerializator(doc,node);
LimeReport::SerializatorIntf* createQRectSerializator(QDomDocument* doc, QDomElement* node)
{
return new LimeReport::XMLQRectSerializator(doc, node);
}
//LimeReport::SerializatorIntf * createQRectFSerializator(QDomDocument *doc, QDomElement *node){
// LimeReport::SerializatorIntf * createQRectFSerializator(QDomDocument *doc, QDomElement
// *node){
// return new LimeReport::XMLQRectFSerializator(doc,node);
//}
bool VARIABLE_IS_NOT_USED registredQRect = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("QRect", createQRectSerializator);
bool VARIABLE_IS_NOT_USED registredQRectF = LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator("QRectF", createQRectSerializator);
bool VARIABLE_IS_NOT_USED registredQRect
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator(
"QRect", createQRectSerializator);
bool VARIABLE_IS_NOT_USED registredQRectF
= LimeReport::XMLAbstractSerializatorFactory::instance().registerCreator(
"QRectF", createQRectSerializator);
}
} // namespace
QVariant LimeReport::XMLQRectSerializator::loadValue()
{
QRect rect;
//QDomElement geometryNode = m_node->firstChildElement(name);
//if (!geometryNode.isNull()){
rect = QRect(
m_node->attribute("x").toInt(),
m_node->attribute("y").toInt(),
m_node->attribute("width").toInt(),
m_node->attribute("height").toInt()
);
// QDomElement geometryNode = m_node->firstChildElement(name);
// if (!geometryNode.isNull()){
rect = QRect(m_node->attribute("x").toInt(), m_node->attribute("y").toInt(),
m_node->attribute("width").toInt(), m_node->attribute("height").toInt());
//}
return rect;
}
void LimeReport::XMLQRectSerializator::save(const QVariant &value, QString name)
void LimeReport::XMLQRectSerializator::save(const QVariant& value, QString name)
{
QDomElement geometryNode = m_doc->createElement(name);
geometryNode.setAttribute("Type","QRect");
geometryNode.setAttribute("x",value.toRect().x());
geometryNode.setAttribute("x",value.toRect().x());
geometryNode.setAttribute("y",value.toRect().y());
geometryNode.setAttribute("width",value.toRect().width());
geometryNode.setAttribute("height",value.toRect().height());
geometryNode.setAttribute("Type", "QRect");
geometryNode.setAttribute("x", value.toRect().x());
geometryNode.setAttribute("x", value.toRect().x());
geometryNode.setAttribute("y", value.toRect().y());
geometryNode.setAttribute("width", value.toRect().width());
geometryNode.setAttribute("height", value.toRect().height());
m_node->appendChild(geometryNode);
}
void LimeReport::XMLQRectFSerializator::save(const QVariant &value, QString name)
void LimeReport::XMLQRectFSerializator::save(const QVariant& value, QString name)
{
QDomElement geometryNode = m_doc->createElement(name);
geometryNode.setAttribute("Type","QRectF");
geometryNode.setAttribute("x",value.toRect().x());
geometryNode.setAttribute("y",value.toRect().y());
geometryNode.setAttribute("width",value.toRect().width());
geometryNode.setAttribute("height",value.toRect().height());
geometryNode.setAttribute("Type", "QRectF");
geometryNode.setAttribute("x", value.toRect().x());
geometryNode.setAttribute("y", value.toRect().y());
geometryNode.setAttribute("width", value.toRect().width());
geometryNode.setAttribute("height", value.toRect().height());
m_node->appendChild(geometryNode);
}
QVariant LimeReport::XMLQRectFSerializator::loadValue()
{
QRectF rect;
//QDomElement geometryNode = m_node->firstChildElement(name);
//if (!geometryNode.isNull()){
rect = QRect(
m_node->attribute("x").toDouble(),
m_node->attribute("y").toDouble(),
m_node->attribute("width").toDouble(),
m_node->attribute("height").toDouble()
);
// QDomElement geometryNode = m_node->firstChildElement(name);
// if (!geometryNode.isNull()){
rect = QRect(m_node->attribute("x").toDouble(), m_node->attribute("y").toDouble(),
m_node->attribute("width").toDouble(), m_node->attribute("height").toDouble());
//}
return rect;

29
limereport/serializators/lrxmlqrectserializator.h
View File

@@ -31,31 +31,32 @@
#define LRXMLQRECTSERIALIZATOR_H
#include "lrserializatorintf.h"
#include <QtXml>
namespace LimeReport{
namespace LimeReport {
class XMLQRectSerializator : public SerializatorIntf
{
class XMLQRectSerializator: public SerializatorIntf {
public:
XMLQRectSerializator(QDomDocument *doc, QDomElement *node):m_doc(doc),m_node(node){}
virtual void save(const QVariant &value,QString name);
XMLQRectSerializator(QDomDocument* doc, QDomElement* node): m_doc(doc), m_node(node) { }
virtual void save(const QVariant& value, QString name);
virtual QVariant loadValue();
private:
QDomDocument *m_doc;
QDomElement *m_node;
QDomDocument* m_doc;
QDomElement* m_node;
};
class XMLQRectFSerializator : public SerializatorIntf
{
class XMLQRectFSerializator: public SerializatorIntf {
public:
XMLQRectFSerializator(QDomDocument *doc, QDomElement *node):m_doc(doc),m_node(node){}
virtual void save(const QVariant &value, QString name);
XMLQRectFSerializator(QDomDocument* doc, QDomElement* node): m_doc(doc), m_node(node) { }
virtual void save(const QVariant& value, QString name);
virtual QVariant loadValue();
private:
QDomDocument *m_doc;
QDomElement *m_node;
QDomDocument* m_doc;
QDomElement* m_node;
};
}
} // namespace LimeReport
#endif // LRXMLQRECTSERIALIZATOR_H

197
limereport/serializators/lrxmlreader.cpp
View File

@@ -27,52 +27,51 @@
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
****************************************************************************/
#include "stdexcept"
#include "lrxmlreader.h"
#include "lrbasedesignintf.h"
#include "lrdesignelementsfactory.h"
#include "lrcollection.h"
#include "lrdesignelementsfactory.h"
#include "lrreporttranslation.h"
#include "stdexcept"
#include <QDebug>
#ifdef BUILD_WITH_EASY_PROFILER
#include "easy/profiler.h"
#else
# define EASY_BLOCK(...)
# define EASY_END_BLOCK
#define EASY_BLOCK(...)
#define EASY_END_BLOCK
#endif
namespace LimeReport{
namespace LimeReport {
XMLReader::XMLReader()
: m_doc(new QDomDocument){}
XMLReader::XMLReader(QSharedPointer<QDomDocument> doc)
: m_doc(doc){}
XMLReader::XMLReader(): m_doc(new QDomDocument) { }
XMLReader::XMLReader(QSharedPointer<QDomDocument> doc): m_doc(doc) { }
bool XMLReader::prepareReader(QDomDocument* doc)
{
Q_UNUSED(doc);
m_error=QLatin1String("Context not initialized");
m_error = QLatin1String("Context not initialized");
return false;
}
int XMLReader::firstLevelItemsCount()
{
if (m_firstNode.childNodes().count()==0) return 0;
if (m_firstNode.childNodes().count() == 0)
return 0;
QDomElement tmpNode = m_firstNode;
int res=0;
while (!tmpNode.isNull()){
int res = 0;
while (!tmpNode.isNull()) {
res++;
tmpNode=tmpNode.nextSiblingElement();
tmpNode = tmpNode.nextSiblingElement();
}
return res;
}
bool XMLReader::first()
{
if (extractFirstNode()){
if (extractFirstNode()) {
m_curNode = m_firstNode;
return !m_curNode.isNull();
}
@@ -91,98 +90,88 @@ bool XMLReader::prior()
return !m_curNode.isNull();
}
QString XMLReader::itemType()
{
return m_curNode.attribute("Type");
}
QString XMLReader::itemType() { return m_curNode.attribute("Type"); }
QString XMLReader::itemClassName()
{
return m_curNode.attribute("ClassName");
}
QString XMLReader::itemClassName() { return m_curNode.attribute("ClassName"); }
bool XMLReader::readItem(QObject *item)
bool XMLReader::readItem(QObject* item)
{
if (!m_curNode.isNull()){
readItemFromNode(item,&m_curNode);
if (!m_curNode.isNull()) {
readItemFromNode(item, &m_curNode);
} else {
m_error=QString("Object %1 not founded").arg(item->objectName());
m_error = QString("Object %1 not founded").arg(item->objectName());
return false;
}
return true;
}
void XMLReader::readItemFromNode(QObject* item,QDomElement *node)
void XMLReader::readItemFromNode(QObject* item, QDomElement* node)
{
EASY_BLOCK("readItemFromNode");
ObjectLoadingStateIntf* lf = dynamic_cast<ObjectLoadingStateIntf*>(item);
if(lf) lf->objectLoadStarted();
for (int i=0;i<node->childNodes().count();i++){
QDomElement currentNode =node->childNodes().at(i).toElement();
if (currentNode.attribute("Type")=="Object"){
readQObject(item,&currentNode);
} else if (currentNode.attribute("Type")=="Collection")
{
readCollection(item,&currentNode);
} else if (currentNode.attribute("Type")=="Translation"){
readTranslation(item,&currentNode);
} else readProperty(item,&currentNode);
if (lf)
lf->objectLoadStarted();
for (int i = 0; i < node->childNodes().count(); i++) {
QDomElement currentNode = node->childNodes().at(i).toElement();
if (currentNode.attribute("Type") == "Object") {
readQObject(item, &currentNode);
} else if (currentNode.attribute("Type") == "Collection") {
readCollection(item, &currentNode);
} else if (currentNode.attribute("Type") == "Translation") {
readTranslation(item, &currentNode);
} else
readProperty(item, &currentNode);
}
if (lf) lf->objectLoadFinished();
if (lf)
lf->objectLoadFinished();
BaseDesignIntf* baseObj = dynamic_cast<BaseDesignIntf*>(item);
if(baseObj) {
foreach(QGraphicsItem* childItem,baseObj->childItems()){
if (baseObj) {
foreach (QGraphicsItem* childItem, baseObj->childItems()) {
BaseDesignIntf* baseItem = dynamic_cast<BaseDesignIntf*>(childItem);
if (baseItem) baseItem->parentObjectLoadFinished();
if (baseItem)
baseItem->parentObjectLoadFinished();
}
}
EASY_END_BLOCK;
}
QString XMLReader::lastError()
{
return m_error;
}
QString XMLReader::lastError() { return m_error; }
void XMLReader::setPassPhrase(const QString &passPhrase)
{
m_passPhrase = passPhrase;
}
void XMLReader::setPassPhrase(const QString& passPhrase) { m_passPhrase = passPhrase; }
bool XMLReader::extractFirstNode()
{
if (m_firstNode.isNull()){
if (m_doc->childNodes().count()==0){
if (!prepareReader(m_doc.data())) return false;
if (m_firstNode.isNull()) {
if (m_doc->childNodes().count() == 0) {
if (!prepareReader(m_doc.data()))
return false;
}
m_firstNode = m_doc->documentElement();
if (!m_firstNode.hasAttributes())
m_firstNode = m_firstNode.firstChildElement();
m_firstNode = m_firstNode.firstChildElement();
}
return !m_firstNode.isNull();
}
void XMLReader::readProperty(QObject *item, QDomElement *node)
void XMLReader::readProperty(QObject* item, QDomElement* node)
{
item->setProperty(node->nodeName().toLatin1(),getValue(node));
item->setProperty(node->nodeName().toLatin1(), getValue(node));
}
QVariant XMLReader::getValue(QDomElement *node)
QVariant XMLReader::getValue(QDomElement* node)
{
CreateSerializator creator = 0;
try {
creator=XMLAbstractSerializatorFactory::instance().objectCreator(
node->attribute("Type")
);
} catch(ReportError &e){
qDebug()<<node->attribute("Type")<<e.what();
creator = XMLAbstractSerializatorFactory::instance().objectCreator(node->attribute("Type"));
} catch (ReportError& e) {
qDebug() << node->attribute("Type") << e.what();
}
if (creator) {
QScopedPointer<SerializatorIntf>serializator(creator(m_doc.data(),node));
QScopedPointer<SerializatorIntf> serializator(creator(m_doc.data(), node));
CryptedSerializator* cs = dynamic_cast<CryptedSerializator*>(serializator.data());
if (cs){
if (cs) {
cs->setPassPhrase(m_passPhrase);
}
return serializator->loadValue();
@@ -195,21 +184,22 @@ void XMLReader::readQObject(QObject* item, QDomElement* node)
EASY_BLOCK("readQObject");
QObject* childItem = qvariant_cast<QObject*>(item->property(node->nodeName().toLatin1()));
if (childItem)
readItemFromNode(childItem,node);
readItemFromNode(childItem, node);
EASY_END_BLOCK;
}
void XMLReader::readCollection(QObject *item, QDomElement *node)
void XMLReader::readCollection(QObject* item, QDomElement* node)
{
EASY_BLOCK("readCollection")
ICollectionContainer* collection = dynamic_cast<ICollectionContainer*>(item);
if (collection){
if (collection) {
QString collectionName = node->nodeName();
for(int i = 0; i < node->childNodes().count(); ++i){
QDomElement currentNode =node->childNodes().at(i).toElement();
QObject* obj = collection->createElement(collectionName,currentNode.attribute("ClassName"));
for (int i = 0; i < node->childNodes().count(); ++i) {
QDomElement currentNode = node->childNodes().at(i).toElement();
QObject* obj
= collection->createElement(collectionName, currentNode.attribute("ClassName"));
if (obj)
readItemFromNode(obj,&currentNode);
readItemFromNode(obj, &currentNode);
}
collection->collectionLoadFinished(collectionName);
}
@@ -219,70 +209,81 @@ void XMLReader::readCollection(QObject *item, QDomElement *node)
void XMLReader::readTranslation(QObject* item, QDomElement* node)
{
ITranslationContainer* tranclationContainer = dynamic_cast<ITranslationContainer*>(item);
if (tranclationContainer){
if (tranclationContainer) {
Translations* translations = tranclationContainer->translations();
for (int langIndex = 0; langIndex<node->childNodes().count(); ++langIndex){
for (int langIndex = 0; langIndex < node->childNodes().count(); ++langIndex) {
QDomElement languageNode = node->childNodes().at(langIndex).toElement();
ReportTranslation* curTranslation = new ReportTranslation((QLocale::Language)(languageNode.attributeNode("Value").value().toInt()));
for (int pageIndex = 0; pageIndex < languageNode.childNodes().count(); ++pageIndex){
ReportTranslation* curTranslation = new ReportTranslation(
(QLocale::Language)(languageNode.attributeNode("Value").value().toInt()));
for (int pageIndex = 0; pageIndex < languageNode.childNodes().count(); ++pageIndex) {
QDomElement pageNode = languageNode.childNodes().at(pageIndex).toElement();
PageTranslation* pageTranslation = curTranslation->createEmptyPageTranslation();
pageTranslation->pageName = pageNode.nodeName();
for (int itemIndex = 0; itemIndex < pageNode.childNodes().count(); ++itemIndex){
for (int itemIndex = 0; itemIndex < pageNode.childNodes().count(); ++itemIndex) {
QDomElement itemNode = pageNode.childNodes().at(itemIndex).toElement();
ItemTranslation* itemTranslation = new ItemTranslation();
itemTranslation->itemName = itemNode.nodeName();
for (int propertyIndex = 0; propertyIndex < itemNode.childNodes().count(); ++propertyIndex){
QDomElement propertyNode = itemNode.childNodes().at(propertyIndex).toElement();
for (int propertyIndex = 0; propertyIndex < itemNode.childNodes().count();
++propertyIndex) {
QDomElement propertyNode
= itemNode.childNodes().at(propertyIndex).toElement();
PropertyTranslation* propertyTranslation = new PropertyTranslation;
propertyTranslation->propertyName = propertyNode.nodeName();
propertyTranslation->value = propertyNode.attribute("Value");
propertyTranslation->sourceValue = propertyNode.attribute("SourceValue");
propertyTranslation->checked = propertyNode.attribute("Checked").compare("Y") == 0;
propertyTranslation->checked
= propertyNode.attribute("Checked").compare("Y") == 0;
itemTranslation->propertyesTranslation.append(propertyTranslation);
}
pageTranslation->itemsTranslation.insert(itemTranslation->itemName, itemTranslation);
pageTranslation->itemsTranslation.insert(itemTranslation->itemName,
itemTranslation);
}
}
translations->insert(curTranslation->language(),curTranslation);
translations->insert(curTranslation->language(), curTranslation);
}
}
}
FileXMLReader::FileXMLReader(QString fileName)
: m_fileName(fileName)
{
}
FileXMLReader::FileXMLReader(QString fileName): m_fileName(fileName) { }
bool FileXMLReader::prepareReader(QDomDocument *doc)
bool FileXMLReader::prepareReader(QDomDocument* doc)
{
if (!m_fileName.isEmpty()){
if (!m_fileName.isEmpty()) {
QFile source(m_fileName);
if (source.open(QFile::ReadOnly)) {
doc->setContent(&source);
if (doc->documentElement().nodeName()!="Report") {
if (doc->documentElement().nodeName() != "Report") {
m_error = QString(QObject::tr("Wrong file format"));
return false;
}
} else {m_error=QString(QObject::tr("File %1 not opened")).arg(m_fileName); return false;}
} else {
m_error = QString(QObject::tr("File %1 not opened")).arg(m_fileName);
return false;
}
}
return true;
}
bool StringXMLreader::prepareReader(QDomDocument *doc)
bool StringXMLreader::prepareReader(QDomDocument* doc)
{
if (!m_content.isEmpty()){
if (!m_content.isEmpty()) {
doc->setContent(m_content);
}else {m_error = QString(QObject::tr("Content string is empty")); return false;}
} else {
m_error = QString(QObject::tr("Content string is empty"));
return false;
}
return true;
}
bool ByteArrayXMLReader::prepareReader(QDomDocument *doc)
bool ByteArrayXMLReader::prepareReader(QDomDocument* doc)
{
if (m_content){
if (m_content) {
doc->setContent(*m_content);
} else {m_error = QString(QObject::tr("Content is empty")); return false;}
} else {
m_error = QString(QObject::tr("Content is empty"));
return false;
}
return true;
}
}
} // namespace LimeReport

72
limereport/serializators/lrxmlreader.h
View File

@@ -30,43 +30,44 @@
#ifndef LRXMLREADER_H
#define LRXMLREADER_H
#include "lrdesignelementsfactory.h"
#include "serializators/lrxmlwriter.h"
#include <QString>
#include <QtXml>
#include "serializators/lrxmlwriter.h"
#include "lrdesignelementsfactory.h"
namespace LimeReport {
namespace LimeReport{
class XMLReader : public ItemsReaderIntf
{
class XMLReader: public ItemsReaderIntf {
public:
XMLReader();
XMLReader(QSharedPointer<QDomDocument> doc);
protected:
//ItemsReaderIntf interface
// ItemsReaderIntf interface
bool first();
bool next();
bool prior();
QString itemType();
QString itemClassName();
bool readItem(QObject *item);
bool readItem(QObject* item);
int firstLevelItemsCount();
QString lastError();
void setPassPhrase(const QString &passPhrase);
void setPassPhrase(const QString& passPhrase);
virtual bool prepareReader(QDomDocument *doc);
virtual bool prepareReader(QDomDocument* doc);
void readItemFromNode(QObject *item, QDomElement *node);
void readProperty(QObject *item, QDomElement *node);
void readQObject(QObject *item, QDomElement *node);
void readCollection(QObject *item, QDomElement *node);
void readTranslation(QObject *item, QDomElement *node);
QVariant getValue(QDomElement *node);
void readItemFromNode(QObject* item, QDomElement* node);
void readProperty(QObject* item, QDomElement* node);
void readQObject(QObject* item, QDomElement* node);
void readCollection(QObject* item, QDomElement* node);
void readTranslation(QObject* item, QDomElement* node);
QVariant getValue(QDomElement* node);
protected:
bool extractFirstNode();
QString m_error;
private:
QSharedPointer<QDomDocument> m_doc;
QDomElement m_curNode;
@@ -74,35 +75,50 @@ private:
QString m_passPhrase;
};
class FileXMLReader : public XMLReader{
class FileXMLReader: public XMLReader {
public:
static ItemsReaderIntf::Ptr create(QString fileName){ return ItemsReaderIntf::Ptr(new FileXMLReader(fileName));}
static ItemsReaderIntf::Ptr create(QString fileName)
{
return ItemsReaderIntf::Ptr(new FileXMLReader(fileName));
}
protected:
virtual bool prepareReader(QDomDocument *doc);
virtual bool prepareReader(QDomDocument* doc);
private:
FileXMLReader(QString fileName);
QString m_fileName;
};
class StringXMLreader : public XMLReader{
class StringXMLreader: public XMLReader {
public:
static ItemsReaderIntf::Ptr create(QString content){ return ItemsReaderIntf::Ptr(new StringXMLreader(content));}
static ItemsReaderIntf::Ptr create(QString content)
{
return ItemsReaderIntf::Ptr(new StringXMLreader(content));
}
protected:
virtual bool prepareReader(QDomDocument *doc);
virtual bool prepareReader(QDomDocument* doc);
private:
StringXMLreader(QString content) : m_content(content){}
StringXMLreader(QString content): m_content(content) { }
QString m_content;
};
class ByteArrayXMLReader : public XMLReader{
class ByteArrayXMLReader: public XMLReader {
public:
static ItemsReaderIntf::Ptr create(QByteArray* content){ return ItemsReaderIntf::Ptr(new ByteArrayXMLReader(content));}
static ItemsReaderIntf::Ptr create(QByteArray* content)
{
return ItemsReaderIntf::Ptr(new ByteArrayXMLReader(content));
}
protected:
virtual bool prepareReader(QDomDocument *doc);
virtual bool prepareReader(QDomDocument* doc);
private:
ByteArrayXMLReader(QByteArray* content): m_content(content){}
ByteArrayXMLReader(QByteArray* content): m_content(content) { }
QByteArray* m_content;
};
}
} // namespace LimeReport
#endif // LRXMLREADER_H

22
limereport/serializators/lrxmlserializatorsfactory.h
View File

@@ -35,21 +35,25 @@
#include <QtXml>
namespace LimeReport{
namespace LimeReport {
typedef SerializatorIntf* (*CreateSerializator)(QDomDocument *doc, QDomElement *parentNode);
typedef SerializatorIntf* (*CreateSerializator)(QDomDocument* doc, QDomElement* parentNode);
class XMLAbstractSerializatorFactory: public SimpleAbstractFactory<SerializatorIntf,QString,CreateSerializator>
{
class XMLAbstractSerializatorFactory:
public SimpleAbstractFactory<SerializatorIntf, QString, CreateSerializator> {
private:
friend class Singleton<XMLAbstractSerializatorFactory>;
public:
XMLAbstractSerializatorFactory(){}
~XMLAbstractSerializatorFactory(){}
XMLAbstractSerializatorFactory(const XMLAbstractSerializatorFactory&){}
XMLAbstractSerializatorFactory& operator = (const XMLAbstractSerializatorFactory&){return *this;}
XMLAbstractSerializatorFactory() { }
~XMLAbstractSerializatorFactory() { }
XMLAbstractSerializatorFactory(const XMLAbstractSerializatorFactory&) { }
XMLAbstractSerializatorFactory& operator=(const XMLAbstractSerializatorFactory&)
{
return *this;
}
};
}
} // namespace LimeReport
#endif // LRXMLABSTRACTSERIALIZATORFABRIC_H

236
limereport/serializators/lrxmlwriter.cpp
View File

@@ -28,58 +28,59 @@
* GNU General Public License for more details. *
****************************************************************************/
#include "lrxmlwriter.h"
#include "lrbasedesignintf.h"
#include "serializators/lrxmlserializatorsfactory.h"
#include "lrcollection.h"
#include "lrreporttranslation.h"
#include "serializators/lrxmlserializatorsfactory.h"
#include <QDebug>
namespace LimeReport{
namespace LimeReport {
XMLWriter::XMLWriter() : m_doc(new QDomDocument)
{
init();
}
XMLWriter::XMLWriter(): m_doc(new QDomDocument) { init(); }
XMLWriter::XMLWriter(QSharedPointer<QDomDocument> doc) : m_doc(doc){
init();
}
XMLWriter::XMLWriter(QSharedPointer<QDomDocument> doc): m_doc(doc) { init(); }
void XMLWriter::init()
{
m_rootElement=m_doc->createElement("Report");
QDomNode xmlNode = m_doc->createProcessingInstruction("xml",
"version=\"1.0\" encoding=\"UTF8\"");
m_doc->insertBefore(xmlNode,m_doc->firstChild());
m_rootElement = m_doc->createElement("Report");
QDomNode xmlNode
= m_doc->createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF8\"");
m_doc->insertBefore(xmlNode, m_doc->firstChild());
m_doc->appendChild(m_rootElement);
}
void XMLWriter::putItem(QObject *item)
void XMLWriter::putItem(QObject* item)
{
QDomElement node=putQObjectItem(item->metaObject()->className(),item);
if (!replaceNode(node,item)) m_rootElement.appendChild(node);
QDomElement node = putQObjectItem(item->metaObject()->className(), item);
if (!replaceNode(node, item))
m_rootElement.appendChild(node);
}
QString XMLWriter::extractClassName(QObject *item)
QString XMLWriter::extractClassName(QObject* item)
{
BaseDesignIntf* baseItem = dynamic_cast<BaseDesignIntf*>(item);
if(baseItem) return baseItem->storageTypeName();
else return item->metaObject()->className();
if (baseItem)
return baseItem->storageTypeName();
else
return item->metaObject()->className();
}
void XMLWriter::putChildQObjectItem(QString name, QObject *item, QDomElement *parentNode)
{
void XMLWriter::putChildQObjectItem(QString name, QObject* item, QDomElement* parentNode)
{
QDomElement itemNode = m_doc->createElement(name);
itemNode.setAttribute("ClassName",extractClassName(item));
itemNode.setAttribute("Type","Object");
if (parentNode) parentNode->appendChild(itemNode);
saveProperties(item,&itemNode);
itemNode.setAttribute("ClassName", extractClassName(item));
itemNode.setAttribute("Type", "Object");
if (parentNode)
parentNode->appendChild(itemNode);
saveProperties(item, &itemNode);
}
bool XMLWriter::setContent(QString fileName)
{
QFile xmlFile(fileName);
if (xmlFile.open(QFile::ReadOnly)){
if (xmlFile.open(QFile::ReadOnly)) {
m_doc->setContent(&xmlFile);
return true;
}
@@ -88,11 +89,12 @@ bool XMLWriter::setContent(QString fileName)
bool XMLWriter::saveToFile(QString fileName)
{
if ((m_doc->childNodes().count()==0)||fileName.isEmpty()) return false;
if ((m_doc->childNodes().count() == 0) || fileName.isEmpty())
return false;
QFile xmlFile(fileName);
if (xmlFile.open(QFile::WriteOnly)) {
QTextStream buffer(&xmlFile);
m_doc->save(buffer,2);
m_doc->save(buffer, 2);
xmlFile.close();
return true;
}
@@ -103,7 +105,7 @@ QString XMLWriter::saveToString()
{
QString res;
QTextStream buffer(&res);
m_doc->save(buffer,2);
m_doc->save(buffer, 2);
return res;
}
@@ -111,90 +113,95 @@ QByteArray XMLWriter::saveToByteArray()
{
QByteArray res;
QTextStream buffer(&res);
m_doc->save(buffer,2);
m_doc->save(buffer, 2);
return res;
}
void XMLWriter::setPassPhrase(const QString &passPhrase)
{
m_passPhrase = passPhrase;
}
void XMLWriter::setPassPhrase(const QString& passPhrase) { m_passPhrase = passPhrase; }
QDomElement XMLWriter::putQObjectItem(QString name, QObject *item)
QDomElement XMLWriter::putQObjectItem(QString name, QObject* item)
{
Q_UNUSED(name)
QDomElement itemNode = m_doc->createElement("object");
itemNode.setAttribute("ClassName",extractClassName(item));
itemNode.setAttribute("Type","Object");
saveProperties(item,&itemNode);
itemNode.setAttribute("ClassName", extractClassName(item));
itemNode.setAttribute("Type", "Object");
saveProperties(item, &itemNode);
return itemNode;
}
void XMLWriter::saveProperty(QString name, QObject* item, QDomElement *node)
void XMLWriter::saveProperty(QString name, QObject* item, QDomElement* node)
{
QString typeName;
if (name.compare("itemIndexMethod")==0)
typeName = item->metaObject()->property(item->metaObject()->indexOfProperty(name.toLatin1())).typeName();
if (name.compare("itemIndexMethod") == 0)
typeName = item->metaObject()
->property(item->metaObject()->indexOfProperty(name.toLatin1()))
.typeName();
else
typeName = item->property(name.toLatin1()).typeName();
CreateSerializator creator=0;
if (isCollection(name, item)) { saveCollection(name,item,node); return; }
if (isTranslation(name, item)) { saveTranslation(name, item, node); return; }
CreateSerializator creator = 0;
if (isCollection(name, item)) {
saveCollection(name, item, node);
return;
}
if (isTranslation(name, item)) {
saveTranslation(name, item, node);
return;
}
if (isQObject(name,item)) {
if (qvariant_cast<QObject *>(item->property(name.toLatin1())))
putQObjectProperty(name,qvariant_cast<QObject *>(item->property(name.toLatin1())),node);
if (isQObject(name, item)) {
if (qvariant_cast<QObject*>(item->property(name.toLatin1())))
putQObjectProperty(name, qvariant_cast<QObject*>(item->property(name.toLatin1())),
node);
else {
qDebug()<<"Warnig property can`t be casted to QObject"<<name;
qDebug() << "Warnig property can`t be casted to QObject" << name;
}
return;
}
if (enumOrFlag(name,item))
creator=XMLAbstractSerializatorFactory::instance().objectCreator(
"enumAndFlags"
);
if (enumOrFlag(name, item))
creator = XMLAbstractSerializatorFactory::instance().objectCreator("enumAndFlags");
else
try {
creator=XMLAbstractSerializatorFactory::instance().objectCreator(typeName);
} catch (LimeReport::ReportError &exception){
qDebug()<<"class name ="<<item->metaObject()->className()
<<"property name="<<name<<" property type="<<typeName
<<exception.what();
}
try {
creator = XMLAbstractSerializatorFactory::instance().objectCreator(typeName);
} catch (LimeReport::ReportError& exception) {
qDebug() << "class name =" << item->metaObject()->className()
<< "property name=" << name << " property type=" << typeName
<< exception.what();
}
if (creator) {
QScopedPointer<SerializatorIntf> serializator(creator(m_doc.data(),node));
QScopedPointer<SerializatorIntf> serializator(creator(m_doc.data(), node));
CryptedSerializator* cs = dynamic_cast<CryptedSerializator*>(serializator.data());
if (cs){
if (cs) {
cs->setPassPhrase(m_passPhrase);
}
serializator->save(
item->property(name.toLatin1()),
name
);
serializator->save(item->property(name.toLatin1()), name);
}
}
void XMLWriter::saveProperties(QObject *item, QDomElement *node)
void XMLWriter::saveProperties(QObject* item, QDomElement* node)
{
for (int i=0;i<item->metaObject()->propertyCount();i++){
saveProperty(item->metaObject()->property(i).name(),item,node);
for (int i = 0; i < item->metaObject()->propertyCount(); i++) {
saveProperty(item->metaObject()->property(i).name(), item, node);
}
}
bool XMLWriter::enumOrFlag(QString name, QObject *item)
bool XMLWriter::enumOrFlag(QString name, QObject* item)
{
return item->metaObject()->property(item->metaObject()->indexOfProperty(name.toLatin1())).isFlagType() ||
item->metaObject()->property(item->metaObject()->indexOfProperty(name.toLatin1())).isEnumType();
return item->metaObject()
->property(item->metaObject()->indexOfProperty(name.toLatin1()))
.isFlagType()
|| item->metaObject()
->property(item->metaObject()->indexOfProperty(name.toLatin1()))
.isEnumType();
}
bool XMLWriter::isCollection(QString propertyName, QObject* item)
{
QMetaProperty prop=item->metaObject()->property(item->metaObject()->indexOfProperty(propertyName.toLatin1()));
//TODO: Migrate to QMetaType
QMetaProperty prop = item->metaObject()->property(
item->metaObject()->indexOfProperty(propertyName.toLatin1()));
// TODO: Migrate to QMetaType
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
return QMetaType::fromName(prop.typeName()).id() == COLLECTION_TYPE_ID;
#else
@@ -204,8 +211,9 @@ bool XMLWriter::isCollection(QString propertyName, QObject* item)
bool XMLWriter::isTranslation(QString propertyName, QObject* item)
{
QMetaProperty prop=item->metaObject()->property(item->metaObject()->indexOfProperty(propertyName.toLatin1()));
//TODO: Migrate to QMetaType
QMetaProperty prop = item->metaObject()->property(
item->metaObject()->indexOfProperty(propertyName.toLatin1()));
// TODO: Migrate to QMetaType
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
return QMetaType::fromName(prop.typeName()).id() == TRANSLATION_TYPE_ID;
#else
@@ -213,14 +221,14 @@ bool XMLWriter::isTranslation(QString propertyName, QObject* item)
#endif
}
void XMLWriter::saveCollection(QString propertyName, QObject *item, QDomElement *node)
void XMLWriter::saveCollection(QString propertyName, QObject* item, QDomElement* node)
{
ICollectionContainer * collection = dynamic_cast<ICollectionContainer*>(item);
QDomElement collectionNode=m_doc->createElement(propertyName);
collectionNode.setAttribute("Type","Collection");
ICollectionContainer* collection = dynamic_cast<ICollectionContainer*>(item);
QDomElement collectionNode = m_doc->createElement(propertyName);
collectionNode.setAttribute("Type", "Collection");
for(int i=0;i<collection->elementsCount(propertyName);i++){
putCollectionItem(collection->elementAt(propertyName,i),&collectionNode);
for (int i = 0; i < collection->elementsCount(propertyName); i++) {
putCollectionItem(collection->elementAt(propertyName, i), &collectionNode);
}
node->appendChild(collectionNode);
@@ -229,26 +237,27 @@ void XMLWriter::saveCollection(QString propertyName, QObject *item, QDomElement
void XMLWriter::saveTranslation(QString propertyName, QObject* item, QDomElement* node)
{
ITranslationContainer* translationsContainer = dynamic_cast<ITranslationContainer*>(item);
if (translationsContainer){
QDomElement translationsNode=m_doc->createElement(propertyName);
translationsNode.setAttribute("Type","Translation");
if (translationsContainer) {
QDomElement translationsNode = m_doc->createElement(propertyName);
translationsNode.setAttribute("Type", "Translation");
Translations* translations = translationsContainer->translations();
foreach(QLocale::Language language, translations->keys()){
QDomElement languageNode = m_doc->createElement(QLocale::languageToString(language).replace(' ', '_'));
languageNode.setAttribute("Value",QString::number(language));
foreach (QLocale::Language language, translations->keys()) {
QDomElement languageNode
= m_doc->createElement(QLocale::languageToString(language).replace(' ', '_'));
languageNode.setAttribute("Value", QString::number(language));
translationsNode.appendChild(languageNode);
ReportTranslation* curTranslation = translations->value(language);
foreach(PageTranslation* page, curTranslation->pagesTranslation()){
foreach (PageTranslation* page, curTranslation->pagesTranslation()) {
QDomElement pageNode = m_doc->createElement(page->pageName);
languageNode.appendChild(pageNode);
foreach(ItemTranslation* item, page->itemsTranslation){
foreach (ItemTranslation* item, page->itemsTranslation) {
QDomElement itemNode = m_doc->createElement(item->itemName);
foreach(PropertyTranslation* property, item->propertyesTranslation){
if (property->sourceValue.compare(property->value) != 0){
foreach (PropertyTranslation* property, item->propertyesTranslation) {
if (property->sourceValue.compare(property->value) != 0) {
QDomElement propertyNode = m_doc->createElement(property->propertyName);
propertyNode.setAttribute("Value",property->value);
propertyNode.setAttribute("Value", property->value);
propertyNode.setAttribute("SourceValue", property->sourceValue);
propertyNode.setAttribute("Checked", property->checked ? "Y":"N");
propertyNode.setAttribute("Checked", property->checked ? "Y" : "N");
itemNode.appendChild(propertyNode);
}
}
@@ -259,53 +268,44 @@ void XMLWriter::saveTranslation(QString propertyName, QObject* item, QDomElement
}
node->appendChild(translationsNode);
}
}
bool XMLWriter::isQObject(QString propertyName, QObject *item)
bool XMLWriter::isQObject(QString propertyName, QObject* item)
{
QMetaProperty prop=item->metaObject()->property(item->metaObject()->indexOfProperty(propertyName.toLatin1()));
//TODO: Migrate to QMetaType
QMetaProperty prop = item->metaObject()->property(
item->metaObject()->indexOfProperty(propertyName.toLatin1()));
// TODO: Migrate to QMetaType
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
return QMetaType::fromName(prop.typeName()).id() == QMetaType::QObjectStar;
#else
return QMetaType::type(prop.typeName()) == QMetaType::QObjectStar;
#endif
}
bool XMLWriter::replaceNode(QDomElement node, QObject* item)
{
QDomElement element = m_rootElement.firstChildElement(item->metaObject()->className());
while (!element.isNull()){
while (!element.isNull()) {
QDomElement objectName = element.firstChildElement(QLatin1String("objectName"));
if (!objectName.isNull()&&(objectName.text()==item->objectName())){
QDomElement removeElement=element;
element=element.nextSiblingElement(item->metaObject()->className());
m_rootElement.replaceChild(node,removeElement);
if (!objectName.isNull() && (objectName.text() == item->objectName())) {
QDomElement removeElement = element;
element = element.nextSiblingElement(item->metaObject()->className());
m_rootElement.replaceChild(node, removeElement);
return true;
}
else element=element.nextSiblingElement(item->metaObject()->className());
} else
element = element.nextSiblingElement(item->metaObject()->className());
}
return false;
}
void XMLWriter::putCollectionItem(QObject *item, QDomElement *parentNode)
void XMLWriter::putCollectionItem(QObject* item, QDomElement* parentNode)
{
putChildQObjectItem("item",item,parentNode);
putChildQObjectItem("item", item, parentNode);
}
void XMLWriter::putQObjectProperty(QString propertyName, QObject* item, QDomElement* parentNode)
{
putChildQObjectItem(propertyName,item,parentNode);
putChildQObjectItem(propertyName, item, parentNode);
}
}
} // namespace LimeReport

38
limereport/serializators/lrxmlwriter.h
View File

@@ -30,43 +30,45 @@
#ifndef LRXMLWRITER_H
#define LRXMLWRITER_H
#include <QtXml>
#include "lrbasedesignintf.h"
#include "serializators/lrstorageintf.h"
#include "serializators/lrxmlserializatorsfactory.h"
#include "lrbasedesignintf.h"
namespace LimeReport{
#include <QtXml>
class XMLWriter : public ItemsWriterIntf
{
namespace LimeReport {
class XMLWriter: public ItemsWriterIntf {
public:
XMLWriter();
XMLWriter(QSharedPointer<QDomDocument> doc);
~XMLWriter() {}
~XMLWriter() { }
private:
// ItemsWriterIntf interface
void putItem(QObject* item);
bool saveToFile(QString fileName);
void putItem(QObject* item);
bool saveToFile(QString fileName);
QString saveToString();
QByteArray saveToByteArray();
void setPassPhrase(const QString &passPhrase);
void setPassPhrase(const QString& passPhrase);
void init();
QDomElement putQObjectItem(QString name, QObject* item);
void putChildQObjectItem(QString name, QObject* item, QDomElement* parentNode);
void putCollectionItem(QObject* item, QDomElement* parentNode=0);
void putQObjectProperty(QString propertyName, QObject *item, QDomElement* parentNode=0);
void putCollectionItem(QObject* item, QDomElement* parentNode = 0);
void putQObjectProperty(QString propertyName, QObject* item, QDomElement* parentNode = 0);
void saveProperties(QObject* item, QDomElement* node);
bool setContent(QString fileName);
void saveProperty(QString name, QObject* item, QDomElement* node);
bool enumOrFlag(QString name, QObject* item);
QString extractClassName(QObject* item);
bool isCollection(QString propertyName, QObject *item);
bool isTranslation(QString propertyName, QObject *item);
void saveCollection(QString propertyName, QObject *item, QDomElement *node);
void saveTranslation(QString propertyName, QObject *item, QDomElement *node);
bool isQObject(QString propertyName, QObject *item);
bool replaceNode(QDomElement node, QObject *item);
bool isCollection(QString propertyName, QObject* item);
bool isTranslation(QString propertyName, QObject* item);
void saveCollection(QString propertyName, QObject* item, QDomElement* node);
void saveTranslation(QString propertyName, QObject* item, QDomElement* node);
bool isQObject(QString propertyName, QObject* item);
bool replaceNode(QDomElement node, QObject* item);
private:
QSharedPointer<QDomDocument> m_doc;
QString m_fileName;
@@ -74,6 +76,6 @@ private:
QString m_passPhrase;
};
}
} // namespace LimeReport
#endif // LRXMLWRITER_H