Herwig Birke
683 lines
23 KiB
C++
683 lines
23 KiB
C++
#include "cdocumentwriter.h"
|
|
#include "ctextdocument.h"
|
|
|
|
#include <QFileInfo>
|
|
|
|
#include <QDebug>
|
|
|
|
|
|
cDocumentWriter::cDocumentWriter(const QString &szFileName, bool bZip) :
|
|
m_bZip(bZip),
|
|
m_szFileName(szFileName),
|
|
m_lpDocument(0)
|
|
{
|
|
QFileInfo fileInfo(szFileName);
|
|
m_szPath = fileInfo.absolutePath();
|
|
}
|
|
|
|
cDocumentWriter::~cDocumentWriter()
|
|
{
|
|
close();
|
|
}
|
|
|
|
bool cDocumentWriter::open()
|
|
{
|
|
if(m_szFileName.isEmpty())
|
|
return(false);
|
|
|
|
if(m_bZip)
|
|
{
|
|
m_zip.setZipName(m_szFileName);
|
|
m_zip.open(QuaZip::mdCreate);
|
|
|
|
QuaZipNewInfo info("document.xml");
|
|
m_zipFile.setZip(&m_zip);
|
|
|
|
if(!m_zipFile.open(QIODevice::WriteOnly, info))
|
|
{
|
|
m_zip.close();
|
|
return(false);
|
|
}
|
|
|
|
setDevice(&m_zipFile);
|
|
}
|
|
else
|
|
{
|
|
m_file.setFileName(m_szFileName);
|
|
if(!m_file.open(QIODevice::WriteOnly | QFile::Text))
|
|
return(false);
|
|
|
|
setDevice(&m_file);
|
|
}
|
|
|
|
setAutoFormatting(true);
|
|
setAutoFormattingIndent(-1);
|
|
writeStartDocument();
|
|
writeStartElement("document");
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool cDocumentWriter::close()
|
|
{
|
|
if(m_bZip)
|
|
{
|
|
if(m_zipFile.isOpen())
|
|
{
|
|
writeEndElement();
|
|
writeEndDocument();
|
|
m_zipFile.close();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(m_file.isOpen())
|
|
{
|
|
writeEndElement();
|
|
writeEndDocument();
|
|
m_file.close();
|
|
}
|
|
}
|
|
|
|
return(true);
|
|
}
|
|
|
|
bool cDocumentWriter::writeDocument(cTextDocument *lpDocument)
|
|
{
|
|
m_lpDocument = lpDocument;
|
|
|
|
QList<QPair<int, QTextBlockFormat>> textBlockFormats;
|
|
QTextBlock textBlock = lpDocument->firstBlock();
|
|
|
|
while(textBlock.isValid())
|
|
{
|
|
int x;
|
|
for(x = 0;x < textBlockFormats.count();x++)
|
|
{
|
|
if(textBlockFormats[x].first == textBlock.blockFormatIndex())
|
|
break;
|
|
}
|
|
if(x >= textBlockFormats.count())
|
|
textBlockFormats.append(QPair<int, QTextBlockFormat>(textBlock.blockFormatIndex(), textBlock.blockFormat()));
|
|
|
|
textBlock = textBlock.next();
|
|
}
|
|
|
|
writeStartElement("documentSettings");
|
|
writeAttribute("documentMargin", QString::number(lpDocument->documentMargin()));
|
|
writeAttribute("indentWidth", QString::number(lpDocument->indentWidth()));
|
|
writeAttribute("textWidth", QString::number(lpDocument->textWidth()));
|
|
writeAttribute("useDesignMetrics", lpDocument->useDesignMetrics() == true ? "true" : "false");
|
|
|
|
writeStartElement("metaInformation");
|
|
writeAttribute("documentTitle", lpDocument->metaInformation(QTextDocument::DocumentTitle));
|
|
writeAttribute("documentUrl", lpDocument->metaInformation(QTextDocument::DocumentUrl));
|
|
writeEndElement();
|
|
|
|
writeStartElement("baseUrl");
|
|
writeAttribute("authority", lpDocument->baseUrl().authority());
|
|
writeAttribute("fragment", lpDocument->baseUrl().fragment());
|
|
writeAttribute("host", lpDocument->baseUrl().host());
|
|
writeAttribute("password", lpDocument->baseUrl().password());
|
|
writeAttribute("path", lpDocument->baseUrl().path());
|
|
writeAttribute("port", QString::number(lpDocument->baseUrl().port()));
|
|
writeAttribute("query", lpDocument->baseUrl().query());
|
|
writeAttribute("scheme", lpDocument->baseUrl().scheme());
|
|
writeAttribute("url", lpDocument->baseUrl().url());
|
|
writeAttribute("userInfo", lpDocument->baseUrl().userInfo());
|
|
writeAttribute("userName", lpDocument->baseUrl().userName());
|
|
writeEndElement();
|
|
|
|
writeStartElement("pageSize");
|
|
writeAttribute("width", QString::number(lpDocument->pageSize().width()));
|
|
writeAttribute("height", QString::number(lpDocument->pageSize().height()));
|
|
writeEndElement();
|
|
writeEndElement();
|
|
|
|
writeStartElement("defaults");
|
|
writeAttribute("defaultCursorMoveStyle", QString::number(lpDocument->defaultCursorMoveStyle()));
|
|
writeAttribute("defaultStyleSheet", lpDocument->defaultStyleSheet());
|
|
|
|
writeStartElement("defaultFont");
|
|
writeFont(lpDocument->defaultFont());
|
|
writeEndElement();
|
|
|
|
writeStartElement("defaultTextOption");
|
|
writeTextOption(lpDocument->defaultTextOption());
|
|
writeEndElement();
|
|
writeEndElement();
|
|
|
|
writeFormats(lpDocument->allFormats());
|
|
writeTextBlockFormats(textBlockFormats);
|
|
|
|
textBlock = lpDocument->firstBlock();
|
|
writeTextBlocks(textBlock);
|
|
|
|
return(true);
|
|
}
|
|
|
|
void cDocumentWriter::writeTextBlockFormats(const QList<QPair<int, QTextBlockFormat>> textBlockFormats)
|
|
{
|
|
writeStartElement("textBlockFormats");
|
|
for(int x = 0;x < textBlockFormats.count();x++)
|
|
{
|
|
writeStartElement("format");
|
|
writeFormat(textBlockFormats[x].second, textBlockFormats[x].first);
|
|
writeEndElement();
|
|
}
|
|
writeEndElement();
|
|
}
|
|
|
|
void cDocumentWriter::writeTextBlocks(QTextBlock& textBlock)
|
|
{
|
|
writeStartElement("textBlocks");
|
|
while(textBlock.isValid())
|
|
{
|
|
writeStartElement("textBlock");
|
|
writeTextBlock(textBlock);
|
|
writeEndElement();
|
|
textBlock = textBlock.next();
|
|
}
|
|
writeEndElement();
|
|
}
|
|
|
|
#include <QTextList>
|
|
#include <QTextTable>
|
|
|
|
void cDocumentWriter::writeTextBlock(const QTextBlock& textBlock)
|
|
{
|
|
QTextCursor cursor(textBlock);
|
|
QTextList* lpTextList = cursor.currentList();
|
|
QTextTable* lpTextTable = cursor.currentTable();
|
|
|
|
writeAttribute("blockFormatIndex", QString::number(textBlock.blockFormatIndex()));
|
|
writeAttribute("charFormatIndex", QString::number(textBlock.charFormatIndex()));
|
|
writeAttribute("listFormatIndex", QString::number(lpTextList == 0 ? -1 : lpTextList->formatIndex()));
|
|
writeAttribute("tableFormatIndex", QString::number(lpTextTable == 0 ? -1 : lpTextTable->formatIndex()));
|
|
|
|
QVector<QTextLayout::FormatRange> textFormats = textBlock.textFormats();
|
|
writeStartElement("textFormats");
|
|
for(int x = 0;x < textFormats.count();x++)
|
|
{
|
|
QTextLayout::FormatRange range = textFormats[x];
|
|
QTextCharFormat format = range.format;
|
|
writeStartElement("range");
|
|
writeAttribute("start", QString::number(range.start));
|
|
writeAttribute("length", QString::number(range.length));
|
|
writeTextCharFormat((QTextCharFormat*)&format, -1, WriteAttribute);
|
|
writeTextFormat((QTextFormat*)&format, -1, WriteAll);
|
|
writeTextCharFormat((QTextCharFormat*)&format, -1, WriteElements);
|
|
writeEndElement();
|
|
}
|
|
writeEndElement();
|
|
|
|
writeTextElement("text", textBlock.text());
|
|
}
|
|
|
|
void cDocumentWriter::writeColor(QColor color)
|
|
{
|
|
writeAttribute("alpha", QString::number(color.alpha()));
|
|
writeAttribute("r", QString::number(color.red()));
|
|
writeAttribute("g", QString::number(color.green()));
|
|
writeAttribute("b", QString::number(color.blue()));
|
|
}
|
|
|
|
void cDocumentWriter::writeGradient(const QGradient* lpGradient)
|
|
{
|
|
writeAttribute("type", QString::number(lpGradient->type()));
|
|
writeTextElement("spread", QString::number(lpGradient->spread()));
|
|
|
|
for(int x = 0;x < lpGradient->stops().count();x++)
|
|
{
|
|
writeStartElement("stop");
|
|
writeAttribute("pos", QString::number(lpGradient->stops()[x].first));
|
|
|
|
writeStartElement("color");
|
|
writeColor(lpGradient->stops()[x].second);
|
|
writeEndElement();
|
|
|
|
writeEndElement();
|
|
}
|
|
}
|
|
|
|
void cDocumentWriter::writePen(const QPen& pen)
|
|
{
|
|
writeAttribute("capStyle", QString::number(pen.capStyle()));
|
|
writeAttribute("dashOffset", QString::number(pen.dashOffset()));
|
|
writeAttribute("isCosmetic", pen.isCosmetic() == true ? "true" : "false");
|
|
writeAttribute("joinStyle", QString::number(pen.joinStyle()));
|
|
writeAttribute("miterLimit", QString::number(pen.miterLimit()));
|
|
writeAttribute("style", QString::number(pen.style()));
|
|
writeAttribute("width", QString::number(pen.width()));
|
|
writeAttribute("widthF", QString::number(pen.widthF()));
|
|
|
|
writeStartElement("brush");
|
|
writeBrush(pen.brush());
|
|
writeEndElement();
|
|
|
|
writeStartElement("color");
|
|
writeColor(pen.color());
|
|
writeEndElement();
|
|
|
|
if(pen.dashPattern().count())
|
|
{
|
|
writeStartElement("dashPattern");
|
|
for(int x = 0;x < pen.dashPattern().count();x++)
|
|
writeTextElement("pattern", QString::number(pen.dashPattern()[x]));
|
|
writeEndElement();
|
|
}
|
|
}
|
|
|
|
void cDocumentWriter::writeBrush(const QBrush& brush)
|
|
{
|
|
writeAttribute("style", QString::number(brush.style()));
|
|
|
|
writeStartElement("color");
|
|
writeColor(brush.color());
|
|
writeEndElement();
|
|
|
|
if(brush.gradient())
|
|
{
|
|
writeStartElement("gradient");
|
|
writeGradient(brush.gradient());
|
|
writeEndElement();
|
|
}
|
|
|
|
//matrix
|
|
//texture oder textureImage
|
|
}
|
|
|
|
void cDocumentWriter::writeFont(const QFont& font)
|
|
{
|
|
writeAttribute("bold", font.bold() == true ? "true" : "false");
|
|
writeAttribute("capitalization", QString::number(font.capitalization()));
|
|
// writeAttribute("defaultFamily", font.defaultFamily());
|
|
// writeAttribute("exactMatch", font.exactMatch() == true ? "true" : "false");
|
|
writeAttribute("family", font.family());
|
|
writeAttribute("fixedPitch", font.fixedPitch() == true ? "true" : "false");
|
|
writeAttribute("hintingPreference", QString::number(font.hintingPreference()));
|
|
writeAttribute("italic", font.italic() == true ? "true" : "false");
|
|
writeAttribute("kerning", font.kerning() == true ? "true" : "false");
|
|
writeAttribute("letterSpacing", QString::number(font.letterSpacing()));
|
|
writeAttribute("letterSpacingType", QString::number(font.letterSpacingType()));
|
|
writeAttribute("overline", QString::number(font.overline()));
|
|
writeAttribute("pixelSize", QString::number(font.pixelSize()));
|
|
writeAttribute("pointSize", QString::number(font.pointSize()));
|
|
writeAttribute("pointSizeF", QString::number(font.pointSizeF()));
|
|
writeAttribute("stretch", QString::number(font.stretch()));
|
|
writeAttribute("strikeOut", font.strikeOut() == true ? "true" : "false");
|
|
writeAttribute("style", QString::number(font.style()));
|
|
writeAttribute("styleHint", QString::number(font.styleHint()));
|
|
writeAttribute("styleName", font.styleName());
|
|
writeAttribute("styleStrategy", QString::number(font.styleStrategy()));
|
|
writeAttribute("underline", font.underline() == true ? "true" : "false");
|
|
writeAttribute("weight", QString::number(font.weight()));
|
|
writeAttribute("wordSpacing", QString::number(font.wordSpacing()));
|
|
}
|
|
|
|
void cDocumentWriter::writeFormat(const QTextFormat& textFormat, int id)
|
|
{
|
|
writeAttribute("type", QString::number(textFormat.type()));
|
|
|
|
if(textFormat.isTableCellFormat())
|
|
{
|
|
writeAttribute("typeText", "tableCellFormat");
|
|
writeTextTableCellFormat((QTextTableCellFormat*)&textFormat, id, WriteAttribute);
|
|
writeTextCharFormat((QTextCharFormat*)&textFormat, id, WriteAttribute);
|
|
writeTextFormat((QTextFormat*)&textFormat, id, WriteAll);
|
|
writeTextTableCellFormat((QTextTableCellFormat*)&textFormat, id, WriteElements);
|
|
writeTextCharFormat((QTextCharFormat*)&textFormat, id, WriteElements);
|
|
}
|
|
else if(textFormat.isTableFormat())
|
|
{
|
|
writeAttribute("typeText", "tableFormat");
|
|
writeTextTableFormat((QTextTableFormat*)&textFormat, id, WriteAttribute);
|
|
writeTextFrameFormat((QTextFrameFormat*)&textFormat, id, WriteAttribute);
|
|
writeTextFormat((QTextFormat*)&textFormat, id, WriteAll);
|
|
writeTextTableFormat((QTextTableFormat*)&textFormat, id, WriteElements);
|
|
writeTextFrameFormat((QTextFrameFormat*)&textFormat, id, WriteElements);
|
|
}
|
|
else if(textFormat.isImageFormat())
|
|
{
|
|
writeAttribute("typeText", "imageFormat");
|
|
writeTextImageFormat((QTextImageFormat*)&textFormat, id, WriteAttribute);
|
|
writeTextCharFormat((QTextCharFormat*)&textFormat, id, WriteAttribute);
|
|
writeTextFormat((QTextFormat*)&textFormat, id, WriteAll);
|
|
writeTextImageFormat((QTextImageFormat*)&textFormat, id, WriteElements);
|
|
writeTextCharFormat((QTextCharFormat*)&textFormat, id, WriteElements);
|
|
}
|
|
else if(textFormat.isFrameFormat())
|
|
{
|
|
writeAttribute("typeText", "frameFormat");
|
|
writeTextFrameFormat((QTextFrameFormat*)&textFormat, id, WriteAttribute);
|
|
writeTextFormat((QTextFormat*)&textFormat, id, WriteAll);
|
|
writeTextFrameFormat((QTextFrameFormat*)&textFormat, id, WriteElements);
|
|
}
|
|
else if(textFormat.isListFormat())
|
|
{
|
|
writeAttribute("typeText", "listFormat");
|
|
writeTextListFormat((QTextListFormat*)&textFormat, id, WriteAttribute);
|
|
writeTextFormat((QTextFormat*)&textFormat, id, WriteAll);
|
|
writeTextListFormat((QTextListFormat*)&textFormat, id, WriteElements);
|
|
}
|
|
else if(textFormat.isBlockFormat())
|
|
{
|
|
writeAttribute("typeText", "blockFormat");
|
|
writeTextBlockFormat((QTextBlockFormat*)&textFormat, id, WriteAttribute);
|
|
writeTextFormat((QTextFormat*)&textFormat, id, WriteAll);
|
|
writeTextBlockFormat((QTextBlockFormat*)&textFormat, id, WriteElements);
|
|
}
|
|
else if(textFormat.isCharFormat())
|
|
{
|
|
writeAttribute("typeText", "charFormat");
|
|
writeTextCharFormat((QTextCharFormat*)&textFormat, id, WriteAttribute);
|
|
writeTextFormat((QTextFormat*)&textFormat, id, WriteAll);
|
|
writeTextCharFormat((QTextCharFormat*)&textFormat, id, WriteElements);
|
|
}
|
|
}
|
|
|
|
void cDocumentWriter::writeTextFormat(QTextFormat* lpTextFormat, int /*id*/, WritePart part)
|
|
{
|
|
if(lpTextFormat->isValid())
|
|
{
|
|
if(part & WriteAttribute)
|
|
{
|
|
writeAttribute("layoutDirection", QString::number(lpTextFormat->layoutDirection()));
|
|
}
|
|
|
|
if(part & WriteElements)
|
|
{
|
|
writeStartElement("background");
|
|
writeBrush(lpTextFormat->background());
|
|
writeEndElement();
|
|
|
|
writeStartElement("foreground");
|
|
writeBrush(lpTextFormat->foreground());
|
|
writeEndElement();
|
|
|
|
writeStartElement("properties");
|
|
QMap<int, QVariant> properties = lpTextFormat->properties();
|
|
QMapIterator<int, QVariant> property(properties);
|
|
|
|
while(property.hasNext())
|
|
{
|
|
property.next();
|
|
|
|
writeStartElement("property");
|
|
writeAttribute("key", QString::number(property.key()));
|
|
writeAttribute("type", QString::number(property.value().type()));
|
|
writeTextElement("value", property.value().toString());
|
|
writeEndElement();
|
|
}
|
|
writeEndElement();
|
|
}
|
|
}
|
|
}
|
|
|
|
void cDocumentWriter::writeFormats(const QVector<QTextFormat> formats)
|
|
{
|
|
writeStartElement("allFormats");
|
|
for(int x = 0;x < formats.count();x++)
|
|
{
|
|
writeStartElement("format");
|
|
writeAttribute("id", QString::number(x));
|
|
writeFormat(formats[x]);
|
|
writeEndElement();
|
|
}
|
|
writeEndElement();
|
|
}
|
|
|
|
void cDocumentWriter::writeTabPositions(const QList<QTextOption::Tab> tabs)
|
|
{
|
|
for(int x = 0;x < tabs.count();x++)
|
|
{
|
|
QTextOption::Tab tab = tabs[x];
|
|
writeStartElement("tabPosition");
|
|
writeAttribute("delimiter", tab.delimiter);
|
|
writeAttribute("position", QString::number(tab.position));
|
|
writeAttribute("type", QString::number(tab.type));
|
|
writeEndElement();
|
|
}
|
|
}
|
|
|
|
void cDocumentWriter::writeTextBlockFormat(QTextBlockFormat* lpTextBlockFormat, int id, WritePart part)
|
|
{
|
|
if(part & WriteAttribute && id != -1)
|
|
writeAttribute("id", QString::number(id));
|
|
|
|
if(lpTextBlockFormat->isValid())
|
|
{
|
|
if(part & WriteAttribute)
|
|
{
|
|
writeAttribute("alignment", QString::number(lpTextBlockFormat->alignment()));
|
|
writeAttribute("topMargin", QString::number(lpTextBlockFormat->topMargin()));
|
|
writeAttribute("leftMargin", QString::number(lpTextBlockFormat->leftMargin()));
|
|
writeAttribute("bottomMargin", QString::number(lpTextBlockFormat->bottomMargin()));
|
|
writeAttribute("rightMargin", QString::number(lpTextBlockFormat->rightMargin()));
|
|
writeAttribute("indent", QString::number(lpTextBlockFormat->indent()));
|
|
writeAttribute("lineHeight", QString::number(lpTextBlockFormat->lineHeight()));
|
|
writeAttribute("lineHeightType", QString::number(lpTextBlockFormat->lineHeightType()));
|
|
writeAttribute("nonBreakableLines", lpTextBlockFormat->nonBreakableLines() == true ? "true" : "false");
|
|
writeAttribute("pageBreakPolicy", QString::number(lpTextBlockFormat->pageBreakPolicy()));
|
|
writeAttribute("textIndent", QString::number(lpTextBlockFormat->textIndent()));
|
|
}
|
|
|
|
if(part & WriteElements)
|
|
{
|
|
writeStartElement("tabPositions");
|
|
writeTabPositions(lpTextBlockFormat->tabPositions());
|
|
writeEndElement();
|
|
}
|
|
}
|
|
}
|
|
|
|
void cDocumentWriter::writeTextCharFormat(QTextCharFormat* lpTextCharFormat, int id, WritePart part)
|
|
{
|
|
if(part & WriteAttribute && id != -1)
|
|
writeAttribute("id", QString::number(id));
|
|
|
|
if(lpTextCharFormat->isValid())
|
|
{
|
|
if(part & WriteAttribute)
|
|
{
|
|
writeAttribute("anchorHref", lpTextCharFormat->anchorHref());
|
|
// writeAttribute("fontCapitalization", QString::number(lpTextCharFormat->fontCapitalization()));
|
|
// writeAttribute("fontFamily", lpTextCharFormat->fontFamily());
|
|
// writeAttribute("fontFixedPitch", lpTextCharFormat->fontFixedPitch() == true ? "true" : "false");
|
|
// writeAttribute("fontHintingPreference", QString::number(lpTextCharFormat->fontHintingPreference()));
|
|
// writeAttribute("fontItalic", lpTextCharFormat->fontItalic() == true ? "true" : "false");
|
|
// writeAttribute("fontKerning", lpTextCharFormat->fontKerning() == true ? "true" : "false");
|
|
// writeAttribute("fontLetterSpacing", QString::number(lpTextCharFormat->fontLetterSpacing()));
|
|
// writeAttribute("fontLetterSpacingType", QString::number(lpTextCharFormat->fontLetterSpacingType()));
|
|
// writeAttribute("fontOverline", QString::number(lpTextCharFormat->fontOverline()));
|
|
// writeAttribute("fontPointSize", QString::number(lpTextCharFormat->fontPointSize()));
|
|
// writeAttribute("fontStretch", QString::number(lpTextCharFormat->fontStretch()));
|
|
// writeAttribute("fontStrikeOut", lpTextCharFormat->fontStrikeOut() == true ? "true" : "false");
|
|
// writeAttribute("fontStyleHint", QString::number(lpTextCharFormat->fontStyleHint()));
|
|
// writeAttribute("fontStyleStrategy", QString::number(lpTextCharFormat->fontStyleStrategy()));
|
|
// writeAttribute("fontUnderline", lpTextCharFormat->fontUnderline() == true ? "true" : "false");
|
|
// writeAttribute("fontWeight", QString::number(lpTextCharFormat->fontWeight()));
|
|
// writeAttribute("fontWordSpacing", QString::number(lpTextCharFormat->fontWordSpacing()));
|
|
writeAttribute("isAnchor", lpTextCharFormat->isAnchor() == true ? "true" : "false");
|
|
writeAttribute("toolTip", lpTextCharFormat->toolTip());
|
|
writeAttribute("verticalAlignment", QString::number(lpTextCharFormat->verticalAlignment()));
|
|
}
|
|
|
|
if(part & WriteElements)
|
|
{
|
|
writeStartElement("textOutline");
|
|
writePen(lpTextCharFormat->textOutline());
|
|
writeEndElement();
|
|
|
|
writeStartElement("anchorNames");
|
|
for(int x = 0;x < lpTextCharFormat->anchorNames().count();x++)
|
|
writeTextElement("anchor", lpTextCharFormat->anchorNames()[x]);
|
|
writeEndElement();
|
|
|
|
writeStartElement("font");
|
|
writeFont(lpTextCharFormat->font());
|
|
writeEndElement();
|
|
|
|
writeStartElement("underlineColor");
|
|
writeColor(lpTextCharFormat->underlineColor());
|
|
writeEndElement();
|
|
}
|
|
}
|
|
}
|
|
|
|
void cDocumentWriter::writeTextFrameFormat(QTextFrameFormat* lpTextFrameFormat, int id, WritePart part)
|
|
{
|
|
if(part & WriteAttribute && id != -1)
|
|
writeAttribute("id", QString::number(id));
|
|
|
|
if(lpTextFrameFormat->isValid())
|
|
{
|
|
if(part & WriteAttribute)
|
|
{
|
|
writeAttribute("border", QString::number(lpTextFrameFormat->border()));
|
|
writeAttribute("borderStyle", QString::number(lpTextFrameFormat->borderStyle()));
|
|
writeAttribute("margin", QString::number(lpTextFrameFormat->margin()));
|
|
writeAttribute("leftMargin", QString::number(lpTextFrameFormat->leftMargin()));
|
|
writeAttribute("topMargin", QString::number(lpTextFrameFormat->topMargin()));
|
|
writeAttribute("rightMargin", QString::number(lpTextFrameFormat->rightMargin()));
|
|
writeAttribute("bottomMargin", QString::number(lpTextFrameFormat->bottomMargin()));
|
|
writeAttribute("width", QString::number(lpTextFrameFormat->width().rawValue()));
|
|
writeAttribute("height", QString::number(lpTextFrameFormat->height().rawValue()));
|
|
writeAttribute("padding", QString::number(lpTextFrameFormat->padding()));
|
|
writeAttribute("pageBreakPolicy", QString::number(lpTextFrameFormat->pageBreakPolicy()));
|
|
writeAttribute("position", QString::number(lpTextFrameFormat->position()));
|
|
}
|
|
|
|
if(part & WriteElements)
|
|
{
|
|
writeStartElement("borderBrush");
|
|
writeBrush(lpTextFrameFormat->borderBrush());
|
|
writeEndElement();
|
|
}
|
|
}
|
|
}
|
|
|
|
void cDocumentWriter::writeTextImageFormat(QTextImageFormat* lpTextImageFormat, int id, WritePart part)
|
|
{
|
|
if(part & WriteAttribute && id != -1)
|
|
writeAttribute("id", QString::number(id));
|
|
|
|
if(lpTextImageFormat->isValid())
|
|
{
|
|
if(part & WriteAttribute)
|
|
{
|
|
writeAttribute("name", lpTextImageFormat->name());
|
|
writeAttribute("height", QString::number(lpTextImageFormat->height()));
|
|
writeAttribute("width", QString::number(lpTextImageFormat->width()));
|
|
}
|
|
|
|
if(m_lpDocument)
|
|
{
|
|
QPixmap pixmap = m_lpDocument->resource(2, lpTextImageFormat->name()).value<QPixmap>();
|
|
if(!pixmap.isNull())
|
|
{
|
|
QString name = lpTextImageFormat->name();
|
|
if(name.left(1) == ':')
|
|
name = name.mid(1);
|
|
if(name.left(1) == '/')
|
|
name = name.mid(1);
|
|
|
|
name = m_szPath + "/" + name;
|
|
QString path = name.left(name.lastIndexOf("/"));
|
|
|
|
QDir dir;
|
|
dir.mkpath(path);
|
|
pixmap.save(name);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void cDocumentWriter::writeTextListFormat(QTextListFormat* lpTextListFormat, int id, WritePart part)
|
|
{
|
|
if(part & WriteAttribute && id != -1)
|
|
writeAttribute("id", QString::number(id));
|
|
|
|
if(lpTextListFormat->isValid())
|
|
{
|
|
if(part & WriteAttribute)
|
|
{
|
|
writeAttribute("indent", QString::number(lpTextListFormat->indent()));
|
|
writeAttribute("numberPrefix", lpTextListFormat->numberPrefix());
|
|
writeAttribute("numberSuffix", lpTextListFormat->numberSuffix());
|
|
writeAttribute("style", QString::number(lpTextListFormat->style()));
|
|
}
|
|
}
|
|
}
|
|
|
|
void cDocumentWriter::writeTextTableCellFormat(QTextTableCellFormat* lpTextTableCellFormat, int id, WritePart part)
|
|
{
|
|
if(part & WriteAttribute && id != -1)
|
|
writeAttribute("id", QString::number(id));
|
|
|
|
if(lpTextTableCellFormat->isValid())
|
|
{
|
|
if(part & WriteAttribute)
|
|
{
|
|
writeAttribute("leftPadding", QString::number(lpTextTableCellFormat->leftPadding()));
|
|
writeAttribute("topPadding", QString::number(lpTextTableCellFormat->topPadding()));
|
|
writeAttribute("rightPadding", QString::number(lpTextTableCellFormat->rightPadding()));
|
|
writeAttribute("bottomPadding", QString::number(lpTextTableCellFormat->bottomPadding()));
|
|
}
|
|
}
|
|
}
|
|
|
|
void cDocumentWriter::writeTextTableFormat(QTextTableFormat* lpTextTableFormat, int id, WritePart part)
|
|
{
|
|
if(part & WriteAttribute && id != -1)
|
|
writeAttribute("id", QString::number(id));
|
|
|
|
if(lpTextTableFormat->isValid())
|
|
{
|
|
if(part & WriteAttribute)
|
|
{
|
|
writeAttribute("alignment", QString::number(lpTextTableFormat->alignment()));
|
|
writeAttribute("cellPadding", QString::number(lpTextTableFormat->cellPadding()));
|
|
writeAttribute("cellSpacing", QString::number(lpTextTableFormat->cellSpacing()));
|
|
writeAttribute("columns", QString::number(lpTextTableFormat->columns()));
|
|
writeAttribute("headerRowCount", QString::number(lpTextTableFormat->headerRowCount()));
|
|
}
|
|
|
|
if(part & WriteElements)
|
|
{
|
|
if(lpTextTableFormat->columnWidthConstraints().count())
|
|
{
|
|
writeStartElement("columnWidthConstraints");
|
|
for(int x = 0;x < lpTextTableFormat->columnWidthConstraints().count();x++)
|
|
{
|
|
writeStartElement("columnWidthConstraint");
|
|
writeAttribute("rawValue", QString::number(lpTextTableFormat->columnWidthConstraints()[x].rawValue()));
|
|
writeAttribute("type", QString::number(lpTextTableFormat->columnWidthConstraints()[x].type()));
|
|
writeEndElement();
|
|
}
|
|
writeEndElement();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void cDocumentWriter::writeTextOption(const QTextOption& textOption)
|
|
{
|
|
writeAttribute("alignment", QString::number(textOption.alignment()));
|
|
writeAttribute("flags", QString::number(textOption.flags()));
|
|
writeAttribute("tabStopDistance", QString::number(textOption.tabStopDistance()));
|
|
writeAttribute("textDirection", QString::number(textOption.textDirection()));
|
|
writeAttribute("useDesignMetrics", textOption.useDesignMetrics() == true ? "true" : "false");
|
|
writeAttribute("wrapMode", QString::number(textOption.wrapMode()));
|
|
|
|
writeStartElement("tabArray");
|
|
for(int x = 0;x < textOption.tabArray().count();x++)
|
|
writeTextElement("tab", QString::number(textOption.tabArray()[x]));
|
|
writeEndElement();
|
|
|
|
writeStartElement("tabs");
|
|
writeTabPositions(textOption.tabs());
|
|
writeEndElement();
|
|
}
|