mirror of
https://github.com/fralx/LimeReport.git
synced 2024-12-23 16:22:58 +03:00
1058 lines
32 KiB
C++
1058 lines
32 KiB
C++
/***************************************************************************
|
|
* This file is part of the Lime Report project *
|
|
* Copyright (C) 2021 by Alexander Arin *
|
|
* arin_a@bk.ru *
|
|
* *
|
|
** GNU General Public License Usage **
|
|
* *
|
|
* This library is free software: you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation, either version 3 of the License, or *
|
|
* (at your option) any later version. *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
|
|
* *
|
|
** GNU Lesser General Public License **
|
|
* *
|
|
* This library 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 (at your option) any later version. *
|
|
* You should have received a copy of the GNU Lesser General Public *
|
|
* License along with this library. *
|
|
* If not, see <http://www.gnu.org/licenses/>. *
|
|
* *
|
|
* This library 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 General Public License for more details. *
|
|
****************************************************************************/
|
|
#include "lrtextitem.h"
|
|
|
|
#include "lrdatasourcemanager.h"
|
|
#include "lrdesignelementsfactory.h"
|
|
#include "lrglobal.h"
|
|
#include "lrpagedesignintf.h"
|
|
#include "lrreportengine_p.h"
|
|
#include "lrsimpletagparser.h"
|
|
#include "lrtextitemeditor.h"
|
|
|
|
#include <QLocale>
|
|
#include <QMenu>
|
|
#include <QMessageBox>
|
|
#include <QTextLayout>
|
|
#include <QtGui>
|
|
|
|
#include <math.h>
|
|
|
|
namespace {
|
|
|
|
const QString xmlTag = "TextItem";
|
|
|
|
LimeReport::BaseDesignIntf* createTextItem(QObject* owner, LimeReport::BaseDesignIntf* parent)
|
|
{
|
|
return new LimeReport::TextItem(owner, parent);
|
|
}
|
|
bool VARIABLE_IS_NOT_USED registred = LimeReport::DesignElementsFactory::instance().registerCreator(
|
|
xmlTag, LimeReport::ItemAttribs(QObject::tr("Text Item"), "TextItem"), createTextItem);
|
|
|
|
} // namespace
|
|
|
|
namespace LimeReport {
|
|
|
|
TextItem::TextItem(QObject* owner, QGraphicsItem* parent):
|
|
ContentItemDesignIntf(xmlTag, owner, parent),
|
|
m_angle(Angle0),
|
|
m_trimValue(true),
|
|
m_allowHTML(false),
|
|
m_allowHTMLInFields(false),
|
|
m_replaceCarriageReturns(false),
|
|
m_followTo(""),
|
|
m_follower(0),
|
|
m_textIndent(0),
|
|
m_textLayoutDirection(Qt::LayoutDirectionAuto),
|
|
m_hideIfEmpty(false),
|
|
m_fontLetterSpacing(0)
|
|
{
|
|
PageItemDesignIntf* pageItem = dynamic_cast<PageItemDesignIntf*>(parent);
|
|
BaseDesignIntf* parentItem = dynamic_cast<BaseDesignIntf*>(parent);
|
|
while (!pageItem && parentItem) {
|
|
parentItem = dynamic_cast<BaseDesignIntf*>(parentItem->parentItem());
|
|
pageItem = dynamic_cast<PageItemDesignIntf*>(parentItem);
|
|
}
|
|
|
|
if (pageItem) {
|
|
QFont defaultFont = pageItem->font();
|
|
setFont(defaultFont);
|
|
}
|
|
Init();
|
|
}
|
|
|
|
TextItem::~TextItem() { }
|
|
|
|
void TextItem::preparePopUpMenu(QMenu& menu)
|
|
{
|
|
QAction* editAction = menu.addAction(QIcon(":/report/images/edit_pecil2.png"), tr("Edit"));
|
|
menu.insertAction(menu.actions().at(0), editAction);
|
|
menu.insertSeparator(menu.actions().at(1));
|
|
|
|
menu.addSeparator();
|
|
|
|
QAction* action = menu.addAction(tr("Auto height"));
|
|
action->setCheckable(true);
|
|
action->setChecked(autoHeight());
|
|
|
|
action = menu.addAction(tr("Allow HTML"));
|
|
action->setCheckable(true);
|
|
action->setChecked(allowHTML());
|
|
|
|
action = menu.addAction(tr("Allow HTML in fields"));
|
|
action->setCheckable(true);
|
|
action->setChecked(allowHTMLInFields());
|
|
|
|
action = menu.addAction(tr("Stretch to max height"));
|
|
action->setCheckable(true);
|
|
action->setChecked(stretchToMaxHeight());
|
|
|
|
action = menu.addAction(tr("Transparent"));
|
|
action->setCheckable(true);
|
|
action->setChecked(backgroundMode() == TransparentMode);
|
|
|
|
action = menu.addAction(tr("Watermark"));
|
|
action->setCheckable(true);
|
|
action->setChecked(isWatermark());
|
|
|
|
action = menu.addAction(tr("Hide if empty"));
|
|
action->setCheckable(true);
|
|
action->setChecked(hideIfEmpty());
|
|
}
|
|
|
|
void TextItem::processPopUpAction(QAction* action)
|
|
{
|
|
if (action->text().compare(tr("Edit")) == 0) {
|
|
this->showEditorDialog();
|
|
}
|
|
if (page()) {
|
|
if (action->text().compare(tr("Auto height")) == 0) {
|
|
page()->setPropertyToSelectedItems("autoHeight", action->isChecked());
|
|
}
|
|
if (action->text().compare(tr("Allow HTML")) == 0) {
|
|
page()->setPropertyToSelectedItems("allowHTML", action->isChecked());
|
|
}
|
|
if (action->text().compare(tr("Allow HTML in fields")) == 0) {
|
|
page()->setPropertyToSelectedItems("allowHTMLInFields", action->isChecked());
|
|
}
|
|
if (action->text().compare(tr("Stretch to max height")) == 0) {
|
|
page()->setPropertyToSelectedItems("stretchToMaxHeight", action->isChecked());
|
|
}
|
|
}
|
|
if (action->text().compare(tr("Transparent")) == 0) {
|
|
if (action->isChecked()) {
|
|
setProperty("backgroundMode", TransparentMode);
|
|
} else {
|
|
setProperty("backgroundMode", OpaqueMode);
|
|
}
|
|
}
|
|
if (action->text().compare(tr("Watermark")) == 0) {
|
|
page()->setPropertyToSelectedItems("watermark", action->isChecked());
|
|
}
|
|
|
|
if (action->text().compare(tr("Hide if empty")) == 0) {
|
|
page()->setPropertyToSelectedItems("hideIfEmpty", action->isChecked());
|
|
}
|
|
|
|
ContentItemDesignIntf::processPopUpAction(action);
|
|
}
|
|
|
|
void TextItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* style, QWidget* widget)
|
|
{
|
|
Q_UNUSED(widget);
|
|
Q_UNUSED(style);
|
|
|
|
TextPtr text = textDocument();
|
|
|
|
painter->save();
|
|
|
|
setupPainter(painter);
|
|
prepareRect(painter, style, widget);
|
|
|
|
QSizeF tmpSize = rect().size() - text->size();
|
|
|
|
if (!painter->clipRegion().isEmpty()) {
|
|
QRegion clipReg
|
|
= painter->clipRegion().xored(painter->clipRegion().subtracted(rect().toRect()));
|
|
painter->setClipRegion(clipReg);
|
|
} else {
|
|
painter->setClipRect(rect());
|
|
}
|
|
|
|
qreal hOffset = 0, vOffset = 0;
|
|
switch (m_angle) {
|
|
case Angle0:
|
|
hOffset = marginSize();
|
|
if ((tmpSize.height() > 0) && (m_alignment & Qt::AlignVCenter)) {
|
|
vOffset = tmpSize.height() / 2;
|
|
}
|
|
if ((tmpSize.height() > 0) && (m_alignment & Qt::AlignBottom)) // allow html
|
|
vOffset = tmpSize.height();
|
|
painter->translate(hOffset, vOffset);
|
|
break;
|
|
case Angle90:
|
|
hOffset = width() - marginSize();
|
|
vOffset = marginSize();
|
|
if (m_alignment & Qt::AlignVCenter) {
|
|
hOffset = (width() - text->size().height()) / 2 + text->size().height();
|
|
}
|
|
|
|
if (m_alignment & Qt::AlignBottom) {
|
|
hOffset = (text->size().height());
|
|
}
|
|
painter->translate(hOffset, vOffset);
|
|
painter->rotate(90);
|
|
break;
|
|
case Angle180:
|
|
hOffset = width() - marginSize();
|
|
vOffset = height() - marginSize();
|
|
if ((tmpSize.width() > 0) && (m_alignment & Qt::AlignVCenter)) {
|
|
vOffset = tmpSize.height() / 2 + text->size().height();
|
|
}
|
|
if ((tmpSize.height() > 0) && (m_alignment & Qt::AlignBottom)) {
|
|
vOffset = (text->size().height());
|
|
}
|
|
painter->translate(hOffset, vOffset);
|
|
painter->rotate(180);
|
|
break;
|
|
case Angle270:
|
|
hOffset = marginSize();
|
|
vOffset = height() - marginSize();
|
|
if (m_alignment & Qt::AlignVCenter) {
|
|
hOffset = (width() - text->size().height()) / 2;
|
|
}
|
|
|
|
if (m_alignment & Qt::AlignBottom) {
|
|
hOffset = (width() - text->size().height());
|
|
}
|
|
painter->translate(hOffset, vOffset);
|
|
painter->rotate(270);
|
|
break;
|
|
case Angle45:
|
|
painter->translate(width() / 2, 0);
|
|
painter->rotate(45);
|
|
text->setTextWidth(sqrt(2 * (pow(width() / 2, 2))));
|
|
break;
|
|
case Angle315:
|
|
painter->translate(0, height() / 2);
|
|
painter->rotate(315);
|
|
text->setTextWidth(sqrt(2 * (pow(height() / 2, 2))));
|
|
break;
|
|
}
|
|
|
|
int lineHeight = painter->fontMetrics().height();
|
|
qreal curpos = 0;
|
|
|
|
if (m_underlines) {
|
|
QPen pen = painter->pen();
|
|
pen.setWidth(m_underlineLineSize);
|
|
painter->setPen(pen);
|
|
}
|
|
|
|
painter->setOpacity(qreal(foregroundOpacity()) / 100);
|
|
QAbstractTextDocumentLayout::PaintContext ctx;
|
|
ctx.palette.setColor(QPalette::Text, fontColor());
|
|
|
|
for (QTextBlock it = text->begin(); it != text->end(); it = it.next()) {
|
|
it.blockFormat().setLineHeight(m_lineSpacing, QTextBlockFormat::LineDistanceHeight);
|
|
for (int i = 0; i < it.layout()->lineCount(); i++) {
|
|
QTextLine line = it.layout()->lineAt(i);
|
|
if (m_underlines) {
|
|
painter->drawLine(QPointF(0, line.rect().bottomLeft().y()),
|
|
QPoint(rect().width(), line.rect().bottomRight().y()));
|
|
lineHeight = line.height() + m_lineSpacing;
|
|
curpos = line.rect().bottom();
|
|
}
|
|
}
|
|
}
|
|
|
|
text->documentLayout()->draw(painter, ctx);
|
|
|
|
if (m_underlines) {
|
|
if (lineHeight < 0)
|
|
lineHeight = painter->fontMetrics().height();
|
|
for (curpos += lineHeight; curpos < rect().height(); curpos += lineHeight) {
|
|
painter->drawLine(QPointF(0, curpos), QPoint(rect().width(), curpos));
|
|
}
|
|
}
|
|
|
|
painter->restore();
|
|
BaseDesignIntf::paint(painter, style, widget);
|
|
}
|
|
|
|
void TextItem::Init()
|
|
{
|
|
m_autoWidth = NoneAutoWidth;
|
|
m_alignment = Qt::AlignLeft | Qt::AlignTop;
|
|
m_autoHeight = false;
|
|
m_textSize = QSizeF();
|
|
m_firstLineSize = 0;
|
|
m_foregroundOpacity = 100;
|
|
m_underlines = false;
|
|
m_adaptFontToSize = false;
|
|
m_underlineLineSize = 1;
|
|
m_lineSpacing = 1;
|
|
m_valueType = Default;
|
|
}
|
|
|
|
void TextItem::setContent(const QString& value)
|
|
{
|
|
if (m_strText.compare(value) != 0) {
|
|
QString oldValue = m_strText;
|
|
|
|
m_strText = value;
|
|
|
|
if (!isLoading()) {
|
|
if (autoHeight() || autoWidth() || hasFollower())
|
|
initTextSizes();
|
|
update(rect());
|
|
notify("content", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
QString TextItem::content() const { return m_strText; }
|
|
|
|
void TextItem::updateItemSize(DataSourceManager* dataManager, RenderPass pass, int maxHeight)
|
|
{
|
|
|
|
if (isNeedExpandContent())
|
|
expandContent(dataManager, pass);
|
|
|
|
if (!isLoading() && (autoHeight() || autoWidth() || hasFollower()))
|
|
initTextSizes();
|
|
|
|
if (m_textSize.width() > width()
|
|
&& ((m_autoWidth == MaxWordLength) || (m_autoWidth == MaxStringLength))) {
|
|
setWidth(m_textSize.width() + marginSize() * 2);
|
|
}
|
|
|
|
if (m_textSize.height() > height()) {
|
|
if (m_autoHeight)
|
|
setHeight(m_textSize.height() + borderLineSize() * 2);
|
|
else if (hasFollower() && !content().isEmpty()) {
|
|
follower()->setContent(getTextPart(0, height()));
|
|
setContent(getTextPart(height(), 0));
|
|
}
|
|
}
|
|
BaseDesignIntf::updateItemSize(dataManager, pass, maxHeight);
|
|
if (isEmpty() && hideIfEmpty())
|
|
setVisible(false);
|
|
}
|
|
|
|
void TextItem::updateLayout()
|
|
{
|
|
// m_layout.setFont(transformToSceneFont(font()));
|
|
// m_layout.setText(content());
|
|
// qreal linePos = 0;
|
|
// m_layout.beginLayout();
|
|
// while(true){
|
|
// QTextLine line = m_layout.createLine();
|
|
// if (!line.isValid()) break;
|
|
// line.setLineWidth(width()-marginSize()*2);
|
|
// line.setPosition(QPoint(marginSize(),linePos));
|
|
// linePos+=line.height();
|
|
// }
|
|
// m_layout.endLayout();
|
|
}
|
|
|
|
bool TextItem::isNeedExpandContent() const
|
|
{
|
|
#if (QT_VERSION < QT_VERSION_CHECK(5, 15, 1))
|
|
QRegExp rx("$*\\{[^{]*\\}");
|
|
#else
|
|
bool result = false;
|
|
QRegularExpression rx("\\$*\\{[^{]*\\}");
|
|
result = content().contains(rx) || isContentBackedUp();
|
|
return result;
|
|
#endif
|
|
return content().contains(rx) || isContentBackedUp();
|
|
}
|
|
|
|
QString TextItem::replaceBR(QString text) const { return text.replace("<br/>", "\n"); }
|
|
|
|
QString TextItem::replaceReturns(QString text) const
|
|
{
|
|
QString result = text.replace("\r\n", "<br/>");
|
|
result = result.replace("\n", "<br/>");
|
|
return result;
|
|
}
|
|
|
|
void TextItem::setTextFont(TextPtr text, const QFont& value) const
|
|
{
|
|
text->setDefaultFont(value);
|
|
if ((m_angle == Angle0) || (m_angle == Angle180)) {
|
|
text->setTextWidth(rect().width() - marginSize() * 2);
|
|
} else {
|
|
text->setTextWidth(rect().height() - marginSize() * 2);
|
|
}
|
|
}
|
|
|
|
void TextItem::adaptFontSize(TextPtr text) const
|
|
{
|
|
QFont _font = transformToSceneFont(font());
|
|
do {
|
|
// qApp->processEvents();
|
|
setTextFont(text, _font);
|
|
if (_font.pixelSize() > 2)
|
|
_font.setPixelSize(_font.pixelSize() - 1);
|
|
else
|
|
break;
|
|
} while (text->size().height() > this->height()
|
|
|| text->size().width() > (this->width()) - marginSize() * 2);
|
|
}
|
|
|
|
int TextItem::underlineLineSize() const { return m_underlineLineSize; }
|
|
|
|
void TextItem::setUnderlineLineSize(int value)
|
|
{
|
|
int oldValue = m_underlineLineSize;
|
|
m_underlineLineSize = value;
|
|
update();
|
|
notify("underlineLineSize", oldValue, value);
|
|
}
|
|
|
|
int TextItem::lineSpacing() const { return m_lineSpacing; }
|
|
|
|
void TextItem::setLineSpacing(int value)
|
|
{
|
|
int oldValue = m_lineSpacing;
|
|
m_lineSpacing = value;
|
|
// if (autoHeight())
|
|
// initTextSizes();
|
|
update();
|
|
notify("lineSpacing", oldValue, value);
|
|
}
|
|
|
|
void TextItem::initTextSizes() const
|
|
{
|
|
TextPtr text = textDocument();
|
|
m_textSize = text->size();
|
|
if (text->begin().isValid() && text->begin().layout()->lineAt(0).isValid())
|
|
m_firstLineSize = text->begin().layout()->lineAt(0).height();
|
|
}
|
|
|
|
QString TextItem::formatDateTime(const QDateTime& value)
|
|
{
|
|
if (m_format.isEmpty()) {
|
|
return value.toString();
|
|
}
|
|
|
|
return value.toString(m_format);
|
|
}
|
|
|
|
QString TextItem::formatNumber(const double value)
|
|
{
|
|
QString str = QString::number(value);
|
|
|
|
if (m_format.contains("%")) {
|
|
#if QT_VERSION < 0x050500
|
|
str.sprintf(m_format.toStdString().c_str(), value);
|
|
#else
|
|
str.asprintf(m_format.toStdString().c_str(), value);
|
|
#endif
|
|
str = str.replace(",", QLocale::system().groupSeparator());
|
|
str = str.replace(".", QLocale::system().decimalPoint());
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
QString TextItem::formatFieldValue()
|
|
{
|
|
if (m_format.isEmpty()) {
|
|
return m_varValue.toString();
|
|
}
|
|
|
|
QVariant value = m_varValue;
|
|
|
|
if (m_valueType != Default) {
|
|
switch (m_valueType) {
|
|
case DateTime: {
|
|
QDateTime dt = QDateTime::fromString(value.toString(), Qt::ISODate);
|
|
value = (dt.isValid() ? QVariant(dt) : m_varValue);
|
|
break;
|
|
}
|
|
case Double: {
|
|
bool bOk = false;
|
|
double dbl = value.toDouble(&bOk);
|
|
value = (bOk ? QVariant(dbl) : m_varValue);
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
switch (value.type()) {
|
|
case QVariant::Date:
|
|
case QVariant::DateTime:
|
|
return formatDateTime(value.toDateTime());
|
|
case QVariant::Double:
|
|
return formatNumber(value.toDouble());
|
|
default:
|
|
return value.toString();
|
|
}
|
|
#else
|
|
switch (value.typeId()) {
|
|
case QMetaType::QDate:
|
|
case QMetaType::QDateTime:
|
|
return formatDateTime(value.toDateTime());
|
|
case QMetaType::Double:
|
|
return formatNumber(value.toDouble());
|
|
default:
|
|
return value.toString();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TextItem::TextPtr TextItem::textDocument() const
|
|
{
|
|
TextPtr text(new QTextDocument);
|
|
QString content = m_trimValue ? m_strText.trimmed() : m_strText;
|
|
|
|
if (allowHTML())
|
|
if (isReplaceCarriageReturns()) {
|
|
text->setHtml(replaceReturns(content));
|
|
} else {
|
|
text->setHtml(content);
|
|
}
|
|
else
|
|
text->setPlainText(content);
|
|
|
|
QTextOption to;
|
|
to.setAlignment(m_alignment);
|
|
to.setTextDirection(m_textLayoutDirection);
|
|
|
|
if (m_autoWidth != MaxStringLength)
|
|
if (m_adaptFontToSize && (!(m_autoHeight || m_autoWidth)))
|
|
to.setWrapMode(QTextOption::WordWrap);
|
|
else
|
|
to.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
|
|
else
|
|
to.setWrapMode(QTextOption::NoWrap);
|
|
|
|
text->setDocumentMargin(0);
|
|
text->setDefaultTextOption(to);
|
|
|
|
QFont _font = transformToSceneFont(font());
|
|
if (m_adaptFontToSize && (!(m_autoHeight || m_autoWidth))) {
|
|
adaptFontSize(text);
|
|
} else {
|
|
setTextFont(text, _font);
|
|
}
|
|
|
|
if (follower())
|
|
text->documentLayout();
|
|
|
|
if (m_lineSpacing != 1 || m_textIndent != 0) {
|
|
|
|
for (QTextBlock block = text->begin(); block.isValid(); block = block.next()) {
|
|
QTextCursor tc = QTextCursor(block);
|
|
QTextBlockFormat fmt = block.blockFormat();
|
|
fmt.setTextIndent(m_textIndent);
|
|
if (fmt.lineHeight() != m_lineSpacing) {
|
|
fmt.setLineHeight(m_lineSpacing, QTextBlockFormat::LineDistanceHeight);
|
|
}
|
|
tc.setBlockFormat(fmt);
|
|
}
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
int TextItem::fontLetterSpacing() const { return m_fontLetterSpacing; }
|
|
|
|
void TextItem::setFontLetterSpacing(int value)
|
|
{
|
|
if (m_fontLetterSpacing != value) {
|
|
int oldValue = m_fontLetterSpacing;
|
|
m_fontLetterSpacing = value;
|
|
QFont curFont = font();
|
|
curFont.setLetterSpacing(QFont::AbsoluteSpacing, m_fontLetterSpacing);
|
|
setFont(curFont);
|
|
notify("fontLetterSpacing", oldValue, value);
|
|
}
|
|
}
|
|
|
|
bool TextItem::hideIfEmpty() const { return m_hideIfEmpty; }
|
|
|
|
void TextItem::setHideIfEmpty(bool hideEmpty)
|
|
{
|
|
if (m_hideIfEmpty != hideEmpty) {
|
|
m_hideIfEmpty = hideEmpty;
|
|
notify("hideIfEmpty", !m_hideIfEmpty, m_hideIfEmpty);
|
|
}
|
|
}
|
|
|
|
bool TextItem::isReplaceCarriageReturns() const { return m_replaceCarriageReturns; }
|
|
|
|
void TextItem::setReplaceCarriageReturns(bool replaceCarriageReturns)
|
|
{
|
|
if (replaceCarriageReturns != m_replaceCarriageReturns) {
|
|
m_replaceCarriageReturns = replaceCarriageReturns;
|
|
update();
|
|
notify("replaceCRwithBR", !replaceCarriageReturns, replaceCarriageReturns);
|
|
}
|
|
}
|
|
|
|
qreal TextItem::textIndent() const { return m_textIndent; }
|
|
|
|
void TextItem::setTextIndent(const qreal& textIndent)
|
|
{
|
|
if (m_textIndent != textIndent) {
|
|
qreal oldValue = m_textIndent;
|
|
m_textIndent = textIndent;
|
|
update();
|
|
notify("textIndent", oldValue, textIndent);
|
|
}
|
|
}
|
|
|
|
Qt::LayoutDirection TextItem::textLayoutDirection() const { return m_textLayoutDirection; }
|
|
|
|
void TextItem::setTextLayoutDirection(const Qt::LayoutDirection& textLayoutDirection)
|
|
{
|
|
if (m_textLayoutDirection != textLayoutDirection) {
|
|
int oldValue = int(m_textLayoutDirection);
|
|
m_textLayoutDirection = textLayoutDirection;
|
|
update();
|
|
notify("textLayoutDirection", oldValue, int(textLayoutDirection));
|
|
}
|
|
}
|
|
|
|
void TextItem::setWatermark(bool watermark)
|
|
{
|
|
if (watermark) {
|
|
setBackgroundMode(TransparentMode);
|
|
}
|
|
BaseDesignIntf::setWatermark(watermark);
|
|
}
|
|
|
|
QString TextItem::followTo() const { return m_followTo; }
|
|
|
|
void TextItem::setFollowTo(const QString& followTo)
|
|
{
|
|
if (m_followTo != followTo) {
|
|
QString oldValue = m_followTo;
|
|
m_followTo = followTo;
|
|
if (!isLoading()) {
|
|
TextItem* fi = scene()->findChild<TextItem*>(oldValue);
|
|
if (fi)
|
|
fi->clearFollower();
|
|
fi = scene()->findChild<TextItem*>(followTo);
|
|
if (fi && fi != this) {
|
|
if (initFollower(followTo)) {
|
|
notify("followTo", oldValue, followTo);
|
|
} else {
|
|
m_followTo = "";
|
|
QMessageBox::critical(0, tr("Error"),
|
|
tr("TextItem \" %1 \" already has folower \" %2 \" ")
|
|
.arg(fi->objectName())
|
|
.arg(fi->follower()->objectName()));
|
|
notify("followTo", followTo, "");
|
|
}
|
|
} else if (m_followTo != "") {
|
|
QMessageBox::critical(0, tr("Error"),
|
|
tr("TextItem \" %1 \" not found!").arg(m_followTo));
|
|
notify("followTo", followTo, "");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TextItem::setFollower(TextItem* follower)
|
|
{
|
|
if (!m_follower) {
|
|
m_follower = follower;
|
|
}
|
|
}
|
|
|
|
void TextItem::clearFollower() { m_follower = 0; }
|
|
|
|
bool TextItem::hasFollower() const { return m_follower != 0; }
|
|
|
|
bool TextItem::initFollower(QString follower)
|
|
{
|
|
TextItem* fi = scene()->findChild<TextItem*>(follower);
|
|
if (fi) {
|
|
if (!fi->hasFollower()) {
|
|
fi->setFollower(this);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void TextItem::pageObjectHasBeenLoaded()
|
|
{
|
|
if (!m_followTo.isEmpty()) {
|
|
initFollower(m_followTo);
|
|
}
|
|
}
|
|
|
|
TextItem::ValueType TextItem::valueType() const { return m_valueType; }
|
|
|
|
void TextItem::setValueType(const ValueType valueType) { m_valueType = valueType; }
|
|
|
|
QString TextItem::format() const { return m_format; }
|
|
|
|
void TextItem::setFormat(const QString& format) { m_format = format; }
|
|
|
|
bool TextItem::allowHTMLInFields() const { return m_allowHTMLInFields; }
|
|
|
|
void TextItem::setAllowHTMLInFields(bool allowHTMLInFields)
|
|
{
|
|
if (m_allowHTMLInFields != allowHTMLInFields) {
|
|
m_allowHTMLInFields = allowHTMLInFields;
|
|
notify("allowHTMLInFields", !m_allowHTMLInFields, allowHTMLInFields);
|
|
update();
|
|
}
|
|
}
|
|
|
|
bool TextItem::allowHTML() const { return m_allowHTML; }
|
|
|
|
void TextItem::setAllowHTML(bool allowHTML)
|
|
{
|
|
if (m_allowHTML != allowHTML) {
|
|
m_allowHTML = allowHTML;
|
|
// if (m_text){
|
|
// if (allowHTML)
|
|
// m_text->setHtml(m_strText);
|
|
// else
|
|
// m_text->setPlainText(m_strText);
|
|
// update();
|
|
// }
|
|
update();
|
|
notify("allowHTML", !m_allowHTML, allowHTML);
|
|
}
|
|
}
|
|
bool TextItem::trimValue() const { return m_trimValue; }
|
|
|
|
void TextItem::setTrimValue(bool value)
|
|
{
|
|
bool oldValue = m_trimValue;
|
|
m_trimValue = value;
|
|
update();
|
|
notify("trimValue", oldValue, value);
|
|
}
|
|
|
|
void TextItem::geometryChangedEvent(QRectF, QRectF) { }
|
|
|
|
bool TextItem::isNeedUpdateSize(RenderPass pass) const
|
|
{
|
|
Q_UNUSED(pass)
|
|
|
|
if ((autoHeight() || autoWidth()) || hasFollower()) {
|
|
initTextSizes();
|
|
}
|
|
|
|
bool res = (m_textSize.height() > geometry().height() && autoHeight())
|
|
|| (m_textSize.width() > geometry().width() && autoWidth()) || m_follower
|
|
|| isNeedExpandContent();
|
|
return res;
|
|
}
|
|
|
|
void TextItem::setAlignment(Qt::Alignment value)
|
|
{
|
|
if (m_alignment != value) {
|
|
Qt::Alignment oldValue = m_alignment;
|
|
m_alignment = value;
|
|
// m_layout.setTextOption(QTextOption(m_alignment));
|
|
if (!isLoading()) {
|
|
update(rect());
|
|
notify("alignment", QVariant(oldValue), QVariant(value));
|
|
}
|
|
}
|
|
}
|
|
|
|
void TextItem::expandContent(DataSourceManager* dataManager, RenderPass pass)
|
|
{
|
|
QString context = content();
|
|
foreach (QString variableName, dataManager->variableNamesByRenderPass(SecondPass)) {
|
|
#if (QT_VERSION < QT_VERSION_CHECK(5, 15, 1))
|
|
QRegExp rx(QString(Const::NAMED_VARIABLE_RX).arg(variableName));
|
|
#else
|
|
QRegularExpression rx = getNamedVariableRegEx(variableName);
|
|
#endif
|
|
if (context.contains(rx) && pass == FirstPass) {
|
|
backupContent();
|
|
break;
|
|
}
|
|
}
|
|
|
|
ExpandType expandType
|
|
= (allowHTML() && !allowHTMLInFields()) ? ReplaceHTMLSymbols : NoEscapeSymbols;
|
|
switch (pass) {
|
|
case FirstPass:
|
|
if (!fillInSecondPass()) {
|
|
context = expandUserVariables(context, pass, expandType, dataManager);
|
|
context = expandScripts(context, dataManager);
|
|
context = expandDataFields(context, expandType, dataManager);
|
|
} else {
|
|
context = expandDataFields(context, expandType, dataManager);
|
|
}
|
|
break;
|
|
case SecondPass:
|
|
if (isContentBackedUp()) {
|
|
restoreContent();
|
|
context = content();
|
|
}
|
|
context = expandUserVariables(context, pass, expandType, dataManager);
|
|
context = expandScripts(context, dataManager);
|
|
}
|
|
|
|
if (expandType == NoEscapeSymbols && !m_varValue.isNull() && m_valueType != Default) {
|
|
setContent(formatFieldValue());
|
|
} else {
|
|
setContent(context);
|
|
}
|
|
}
|
|
|
|
void TextItem::setAutoHeight(bool value)
|
|
{
|
|
if (m_autoHeight != value) {
|
|
bool oldValue = m_autoHeight;
|
|
m_autoHeight = value;
|
|
notify("autoHeight", oldValue, value);
|
|
}
|
|
}
|
|
|
|
void TextItem::setAutoWidth(TextItem::AutoWidth value)
|
|
{
|
|
if (m_autoWidth != value) {
|
|
TextItem::AutoWidth oldValue = m_autoWidth;
|
|
m_autoWidth = value;
|
|
notify("autoWidth", oldValue, value);
|
|
}
|
|
}
|
|
|
|
void TextItem::setAdaptFontToSize(bool value)
|
|
{
|
|
if (m_adaptFontToSize != value) {
|
|
bool oldValue = m_adaptFontToSize;
|
|
m_adaptFontToSize = value;
|
|
// initText();
|
|
invalidateRect(rect());
|
|
notify("updateFontToSize", oldValue, value);
|
|
}
|
|
}
|
|
|
|
bool TextItem::canBeSplitted(int height) const
|
|
{
|
|
QFontMetrics fm(font());
|
|
return height > m_firstLineSize;
|
|
}
|
|
|
|
QString TextItem::extractText(QTextBlock& curBlock, int height)
|
|
{
|
|
int curLine = 0;
|
|
int linesHeight = 0;
|
|
QString resultText;
|
|
for (; curBlock != curBlock.document()->end() || curLine <= curBlock.lineCount();
|
|
curBlock = curBlock.next(), curLine = 0, resultText += '\n') {
|
|
linesHeight += curBlock.blockFormat().topMargin();
|
|
for (; curLine < curBlock.layout()->lineCount(); curLine++) {
|
|
linesHeight += curBlock.layout()->lineAt(curLine).height() + lineSpacing();
|
|
if (height > 0 && linesHeight > (height - borderLineSize() * 2)) {
|
|
goto loop_exit;
|
|
}
|
|
resultText += curBlock.text().mid(curBlock.layout()->lineAt(curLine).textStart(),
|
|
curBlock.layout()->lineAt(curLine).textLength());
|
|
}
|
|
}
|
|
loop_exit:
|
|
return resultText;
|
|
}
|
|
|
|
QString TextItem::getTextPart(int height, int skipHeight)
|
|
{
|
|
|
|
QString resultText = "";
|
|
TextPtr text = textDocument();
|
|
text->size().height();
|
|
QTextBlock curBlock = text->begin();
|
|
QTextCursor cursor(text.data());
|
|
cursor.movePosition(QTextCursor::Start);
|
|
|
|
if (skipHeight > 0) {
|
|
resultText = extractText(curBlock, skipHeight);
|
|
cursor.movePosition(QTextCursor::Right, QTextCursor::MoveAnchor, resultText.length());
|
|
}
|
|
|
|
resultText = extractText(curBlock, height);
|
|
cursor.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor, resultText.length());
|
|
|
|
if (allowHTML()) {
|
|
resultText = cursor.selection().toHtml();
|
|
resultText.remove("<!--StartFragment-->");
|
|
resultText.remove("<!--EndFragment-->");
|
|
} else {
|
|
resultText = cursor.selection().toPlainText();
|
|
}
|
|
|
|
return resultText;
|
|
}
|
|
|
|
void TextItem::restoreLinksEvent()
|
|
{
|
|
if (!followTo().isEmpty()) {
|
|
BaseDesignIntf* pi = dynamic_cast<BaseDesignIntf*>(parentItem());
|
|
if (pi) {
|
|
foreach (BaseDesignIntf* bi, pi->childBaseItems()) {
|
|
if (bi->patternName().compare(followTo()) == 0) {
|
|
TextItem* ti = dynamic_cast<TextItem*>(bi);
|
|
if (ti) {
|
|
ti->setFollower(this);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BaseDesignIntf* TextItem::cloneUpperPart(int height, QObject* owner, QGraphicsItem* parent)
|
|
{
|
|
TextItem* upperPart = dynamic_cast<TextItem*>(cloneItem(itemMode(), owner, parent));
|
|
upperPart->setContent(getTextPart(height, 0));
|
|
upperPart->initTextSizes();
|
|
upperPart->setHeight(upperPart->textSize().height() + borderLineSize() * 2);
|
|
return upperPart;
|
|
}
|
|
|
|
BaseDesignIntf* TextItem::cloneBottomPart(int height, QObject* owner, QGraphicsItem* parent)
|
|
{
|
|
TextItem* bottomPart = dynamic_cast<TextItem*>(cloneItem(itemMode(), owner, parent));
|
|
bottomPart->setContent(getTextPart(0, height));
|
|
bottomPart->initTextSizes();
|
|
bottomPart->setHeight(bottomPart->textSize().height() + borderLineSize() * 2);
|
|
return bottomPart;
|
|
}
|
|
|
|
BaseDesignIntf* TextItem::createSameTypeItem(QObject* owner, QGraphicsItem* parent)
|
|
{
|
|
return new TextItem(owner, parent);
|
|
}
|
|
|
|
BaseDesignIntf* TextItem::cloneEmpty(int height, QObject* owner, QGraphicsItem* parent)
|
|
{
|
|
TextItem* empty = dynamic_cast<TextItem*>(cloneItem(itemMode(), owner, parent));
|
|
empty->setContent("");
|
|
empty->setHeight(height);
|
|
return empty;
|
|
}
|
|
|
|
void TextItem::objectLoadFinished()
|
|
{
|
|
ItemDesignIntf::objectLoadFinished();
|
|
// if (itemMode() == DesignMode || !isNeedExpandContent()){
|
|
// if (autoHeight() && autoWidth())
|
|
// initTextSizes();
|
|
// }
|
|
}
|
|
|
|
void TextItem::setTextItemFont(QFont value)
|
|
{
|
|
if (font() != value) {
|
|
QFont oldValue = font();
|
|
value.setLetterSpacing(QFont::AbsoluteSpacing, m_fontLetterSpacing);
|
|
setFont(value);
|
|
if (!isLoading())
|
|
update();
|
|
notify("font", oldValue, value);
|
|
}
|
|
}
|
|
|
|
QWidget* TextItem::defaultEditor()
|
|
{
|
|
QSettings* l_settings = (page()->settings() != 0) ? page()->settings()
|
|
: (page()->reportEditor() != 0) ? page()->reportEditor()->settings()
|
|
: 0;
|
|
QWidget* editor = new TextItemEditor(this, page(), l_settings);
|
|
editor->setAttribute(Qt::WA_DeleteOnClose);
|
|
return editor;
|
|
}
|
|
|
|
void TextItem::setBackgroundOpacity(int value)
|
|
{
|
|
if (opacity() != value) {
|
|
int oldValue = opacity();
|
|
setOpacity(value);
|
|
notify("backgroundOpacity", oldValue, value);
|
|
}
|
|
}
|
|
|
|
void TextItem::setBackgroundModeProperty(BaseDesignIntf::BGMode value)
|
|
{
|
|
if (value != backgroundMode()) {
|
|
BaseDesignIntf::BGMode oldValue = backgroundMode();
|
|
setBackgroundMode(value);
|
|
notify("backgroundMode", oldValue, value);
|
|
}
|
|
}
|
|
|
|
void TextItem::setBackgroundColorProperty(QColor value)
|
|
{
|
|
if (value != backgroundColor()) {
|
|
QColor oldValue = backgroundColor();
|
|
setBackgroundColor(value);
|
|
notify("backgroundColor", oldValue, value);
|
|
}
|
|
}
|
|
|
|
void TextItem::setFontColorProperty(QColor value)
|
|
{
|
|
if (value != fontColor()) {
|
|
QColor oldValue = fontColor();
|
|
setFontColor(value);
|
|
notify("fontColor", oldValue, value);
|
|
}
|
|
}
|
|
|
|
TextItem::AngleType TextItem::angle() const { return m_angle; }
|
|
|
|
void TextItem::setAngle(const AngleType& value)
|
|
{
|
|
if (m_angle != value) {
|
|
AngleType oldValue = m_angle;
|
|
m_angle = value;
|
|
if (!isLoading()) {
|
|
update();
|
|
notify("angle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
void TextItem::setForegroundOpacity(int value)
|
|
{
|
|
if (value > 100) {
|
|
value = 100;
|
|
} else if (value < 0) {
|
|
value = 0;
|
|
}
|
|
if (m_foregroundOpacity != value) {
|
|
int oldValue = m_foregroundOpacity;
|
|
m_foregroundOpacity = value;
|
|
update();
|
|
notify("foregroundOpacity", oldValue, value);
|
|
}
|
|
}
|
|
|
|
void TextItem::setUnderlines(bool value)
|
|
{
|
|
if (m_underlines != value) {
|
|
bool oldValue = m_underlines;
|
|
m_underlines = value;
|
|
update();
|
|
notify("underlines", oldValue, value);
|
|
}
|
|
}
|
|
|
|
} // namespace LimeReport
|