mirror of
https://github.com/fralx/LimeReport.git
synced 2026-01-10 21:38:06 +03:00
1167 lines
38 KiB
C++
1167 lines
38 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 "lrbanddesignintf.h"
|
|
|
|
#include "lrglobal.h"
|
|
#include "lritemdesignintf.h"
|
|
|
|
#include <QGraphicsScene>
|
|
#include <QGraphicsSceneMouseEvent>
|
|
#include <QMenu>
|
|
|
|
#include <algorithm>
|
|
|
|
namespace LimeReport {
|
|
|
|
BandMarker::BandMarker(BandDesignIntf* band, QGraphicsItem* parent):
|
|
QGraphicsItem(parent),
|
|
m_rect(0, 0, 30, 30),
|
|
m_band(band)
|
|
{
|
|
setAcceptHoverEvents(true);
|
|
}
|
|
|
|
QRectF BandMarker::boundingRect() const { return m_rect; }
|
|
|
|
void BandMarker::paint(QPainter* painter, const QStyleOptionGraphicsItem* /**option*/,
|
|
QWidget* /*widget*/)
|
|
{
|
|
painter->save();
|
|
painter->setOpacity(Const::BAND_MARKER_OPACITY);
|
|
painter->fillRect(boundingRect(), m_color);
|
|
painter->setOpacity(1);
|
|
painter->setPen(QPen(QBrush(Qt::lightGray), 2));
|
|
painter->fillRect(QRectF(boundingRect().bottomLeft().x(), boundingRect().bottomLeft().y() - 4,
|
|
boundingRect().width(), 4),
|
|
Qt::lightGray);
|
|
painter->setRenderHint(QPainter::Antialiasing);
|
|
qreal size = (boundingRect().width() < boundingRect().height()) ? boundingRect().width()
|
|
: boundingRect().height();
|
|
QRectF r = QRectF(0, 0, size, size);
|
|
painter->setBrush(Qt::white);
|
|
painter->setPen(Qt::white);
|
|
painter->drawEllipse(r.adjusted(5, 5, -5, -5));
|
|
if (m_band->isSelected()) {
|
|
painter->setBrush(LimeReport::Const::SELECTION_COLOR);
|
|
painter->drawEllipse(r.adjusted(7, 7, -7, -7));
|
|
}
|
|
|
|
painter->restore();
|
|
}
|
|
|
|
void BandMarker::setHeight(qreal height)
|
|
{
|
|
if (m_rect.height() != height) {
|
|
prepareGeometryChange();
|
|
m_rect.setHeight(height);
|
|
}
|
|
}
|
|
|
|
void BandMarker::setWidth(qreal width)
|
|
{
|
|
if (m_rect.width() != width) {
|
|
prepareGeometryChange();
|
|
m_rect.setWidth(width);
|
|
}
|
|
}
|
|
|
|
void BandMarker::setColor(QColor color)
|
|
{
|
|
if (m_color != color) {
|
|
m_color = color;
|
|
update(boundingRect());
|
|
}
|
|
}
|
|
|
|
void BandMarker::mousePressEvent(QGraphicsSceneMouseEvent* event)
|
|
{
|
|
if (event->button() == Qt::LeftButton) {
|
|
if (!(event->modifiers() & Qt::ControlModifier))
|
|
m_band->scene()->clearSelection();
|
|
m_band->setSelected(true);
|
|
m_oldBandPos = m_band->pos();
|
|
update(0, 0, boundingRect().width(), boundingRect().width());
|
|
}
|
|
}
|
|
|
|
void BandMarker::contextMenuEvent(QGraphicsSceneContextMenuEvent* event)
|
|
{
|
|
m_band->contextMenuEvent(event);
|
|
}
|
|
|
|
void BandMarker::hoverMoveEvent(QGraphicsSceneHoverEvent* event)
|
|
{
|
|
if (QRectF(0, height() - 10, width(), 10).contains(event->pos())) {
|
|
setCursor(Qt::SizeVerCursor);
|
|
} else {
|
|
unsetCursor();
|
|
}
|
|
}
|
|
|
|
void BandMarker::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
|
|
{
|
|
qreal delta = event->pos().y() - event->lastPos().y();
|
|
if (hasCursor()) {
|
|
m_band->setHeight(m_band->height() + delta);
|
|
} else {
|
|
if (!m_band->isFixedPos())
|
|
m_band->setItemPos(QPointF(m_band->pos().x(), m_band->pos().y() + delta));
|
|
}
|
|
}
|
|
|
|
void BandMarker::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
|
|
{
|
|
Q_UNUSED(event)
|
|
m_band->posChanged(m_band, m_band->pos(), m_oldBandPos);
|
|
}
|
|
|
|
BandDesignIntf::BandDesignIntf(BandsType bandType, const QString& xmlTypeName, QObject* owner,
|
|
QGraphicsItem* parent):
|
|
ItemsContainerDesignInft(xmlTypeName, owner, parent),
|
|
m_bandType(bandType),
|
|
m_bandIndex(static_cast<int>(bandType)),
|
|
m_dataSourceName(""),
|
|
m_autoHeight(true),
|
|
m_keepBottomSpace(false),
|
|
m_keepTopSpace(true),
|
|
m_parentBand(0),
|
|
m_parentBandName(""),
|
|
m_bandMarker(0),
|
|
m_tryToKeepTogether(false),
|
|
m_splitable(false),
|
|
m_keepFooterTogether(false),
|
|
m_maxScalePercent(0),
|
|
m_sliceLastRow(false),
|
|
m_printIfEmpty(false),
|
|
m_columnsCount(1),
|
|
m_columnIndex(0),
|
|
m_columnsFillDirection(Horizontal),
|
|
m_reprintOnEachPage(false),
|
|
m_startNewPage(false),
|
|
m_startFromNewPage(false),
|
|
m_printAlways(false),
|
|
m_repeatOnEachRow(false),
|
|
m_useAlternateBackgroundColor(false),
|
|
m_bottomSpace(0),
|
|
m_shiftItems(0)
|
|
{
|
|
setPossibleResizeDirectionFlags(ResizeBottom);
|
|
setPossibleMoveFlags(TopBotom);
|
|
|
|
if (parent) {
|
|
BaseDesignIntf* parentItem = dynamic_cast<BaseDesignIntf*>(parent);
|
|
if (parentItem)
|
|
setWidth(parentItem->width());
|
|
}
|
|
|
|
setBackgroundMode(BaseDesignIntf::TransparentMode);
|
|
setFillTransparentInDesignMode(false);
|
|
setHeight(100);
|
|
setFixedPos(true);
|
|
setFlag(QGraphicsItem::ItemClipsChildrenToShape);
|
|
m_bandMarker = new BandMarker(this);
|
|
m_bandMarker->setColor(Qt::magenta);
|
|
m_bandMarker->setHeight(height());
|
|
m_bandMarker->setPos(pos().x() - m_bandMarker->width()
|
|
- (itemMode() == ItemModes::PrintMode ? boundingRect().width() : 0),
|
|
pos().y());
|
|
if (scene())
|
|
scene()->addItem(m_bandMarker);
|
|
|
|
m_bandNameLabel = new BandNameLabel(this);
|
|
m_bandNameLabel->setVisible(false);
|
|
if (scene())
|
|
scene()->addItem(m_bandNameLabel);
|
|
m_alternateBackgroundColor = backgroundColor();
|
|
connect(this, SIGNAL(propertyObjectNameChanged(QString, QString)), this,
|
|
SLOT(slotPropertyObjectNameChanged(const QString&, const QString&)));
|
|
}
|
|
|
|
BandDesignIntf::~BandDesignIntf()
|
|
{
|
|
delete m_bandMarker;
|
|
delete m_bandNameLabel;
|
|
}
|
|
|
|
int extractItemIndex(const BaseDesignIntf* item)
|
|
{
|
|
QString objectName = extractClassName(item->metaObject()->className());
|
|
QString value = item->objectName().right(item->objectName().size() - objectName.size());
|
|
return value.toInt();
|
|
}
|
|
|
|
QString BandDesignIntf::translateBandName(const BaseDesignIntf* item) const
|
|
{
|
|
QString defaultBandName = extractClassName(item->metaObject()->className()).toLatin1()
|
|
+ QString::number(extractItemIndex(item));
|
|
if (item->objectName().compare(defaultBandName) == 0) {
|
|
return tr(extractClassName(item->metaObject()->className()).toLatin1())
|
|
+ QString::number(extractItemIndex(item));
|
|
} else {
|
|
return item->objectName();
|
|
}
|
|
}
|
|
|
|
void BandDesignIntf::setBackgroundModeProperty(BaseDesignIntf::BGMode value)
|
|
{
|
|
if (value != backgroundMode()) {
|
|
BaseDesignIntf::BGMode oldValue = backgroundMode();
|
|
setBackgroundMode(value);
|
|
notify("backgroundMode", oldValue, value);
|
|
}
|
|
}
|
|
|
|
void BandDesignIntf::setBackgroundOpacity(int value)
|
|
{
|
|
if (opacity() != value) {
|
|
int oldValue = opacity();
|
|
setOpacity(value);
|
|
notify("backgroundOpacity", oldValue, value);
|
|
}
|
|
}
|
|
|
|
bool BandDesignIntf::isNeedUpdateSize(RenderPass pass) const
|
|
{
|
|
foreach (BaseDesignIntf* item, childBaseItems()) {
|
|
if (item->isNeedUpdateSize(pass))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void BandDesignIntf::copyBandAttributes(BandDesignIntf* source)
|
|
{
|
|
this->copyBookmarks(source);
|
|
this->setBackgroundColor(source->backgroundColor());
|
|
}
|
|
|
|
void BandDesignIntf::paint(QPainter* painter, const QStyleOptionGraphicsItem* option,
|
|
QWidget* widget)
|
|
{
|
|
prepareRect(painter, option, widget);
|
|
|
|
if (itemMode() & DesignMode) {
|
|
painter->save();
|
|
QString bandText = bandTitle();
|
|
QFont font("Arial", 7 * Const::fontFACTOR, -1, true);
|
|
QFontMetrics fontMetrics(font);
|
|
|
|
QVector<QRectF> bandNameRects;
|
|
bandNameRects.push_back(QRectF(8, 8, fontMetrics.boundingRect(" " + bandText + " ").width(),
|
|
fontMetrics.height()));
|
|
// bandNameRects.push_back(QRectF(width()-fontMetrics.width(" "+bandText+"
|
|
// "),2,fontMetrics.width(" "+bandText+" "),fontMetrics.height()));
|
|
// bandNameRects.push_back(QRectF(2,height()-fontMetrics.height(),fontMetrics.width("
|
|
// "+bandText+" "),fontMetrics.height()));
|
|
// bandNameRects.push_back(QRectF(width()-fontMetrics.width(" "+bandText+"
|
|
// "),height()-fontMetrics.height(),fontMetrics.width(" "+bandText+"
|
|
// "),fontMetrics.height())); if (bandNameRects[0].intersects(bandNameRects[2]))
|
|
// bandNameRects.remove(2,2); if (isSelected()) ppainter->setPen(QColor(167,244,167));
|
|
// else ppainter->setPen(QColor(220,220,220));
|
|
|
|
painter->setFont(font);
|
|
for (int i = 0; i < bandNameRects.count(); i++) {
|
|
QRectF labelRect = bandNameRects[i].adjusted(-2, -2, 2, 2);
|
|
if ((labelRect.height()) < height() && (childBaseItems().isEmpty()) && !isSelected()) {
|
|
painter->setRenderHint(QPainter::Antialiasing);
|
|
painter->setBrush(bandColor());
|
|
painter->setOpacity(Const::BAND_NAME_AREA_OPACITY);
|
|
painter->drawRoundedRect(labelRect, 8, 8);
|
|
painter->setOpacity(Const::BAND_NAME_TEXT_OPACITY);
|
|
painter->setPen(Qt::black);
|
|
painter->drawText(bandNameRects[i], Qt::AlignHCenter, bandText);
|
|
}
|
|
}
|
|
painter->restore();
|
|
}
|
|
BaseDesignIntf::paint(painter, option, widget);
|
|
}
|
|
|
|
QRectF BandDesignIntf::boundingRect() const
|
|
{
|
|
return ItemsContainerDesignInft::boundingRect().adjusted(0, -4, 0, 4);
|
|
}
|
|
|
|
void BandDesignIntf::translateBandsName()
|
|
{
|
|
tr("DataBand");
|
|
tr("DataHeaderBand");
|
|
tr("DataFooterBand");
|
|
tr("ReportHeader");
|
|
tr("ReportFooter");
|
|
tr("PageHeader");
|
|
tr("PageFooter");
|
|
tr("SubDetailBand");
|
|
tr("SubDetailHeaderBand");
|
|
tr("SubDetailFooterBand");
|
|
tr("GroupBandHeader");
|
|
tr("GroupBandFooter");
|
|
tr("TearOffBand");
|
|
}
|
|
|
|
BandDesignIntf::BandsType BandDesignIntf::bandType() const { return m_bandType; }
|
|
|
|
QString BandDesignIntf::bandTitle() const
|
|
{
|
|
QString result = translateBandName(this);
|
|
if (parentBand())
|
|
result += tr(" connected to ") + translateBandName(parentBand());
|
|
return result;
|
|
}
|
|
|
|
QIcon BandDesignIntf::bandIcon() const { return QIcon(); }
|
|
|
|
int BandDesignIntf::bandIndex() const { return m_bandIndex; }
|
|
|
|
void BandDesignIntf::setBandIndex(int value) { m_bandIndex = value; }
|
|
|
|
void BandDesignIntf::changeBandIndex(int value, bool firstTime)
|
|
{
|
|
int indexOffset;
|
|
|
|
if (firstTime && bandHeader())
|
|
value += 1;
|
|
|
|
indexOffset = value - m_bandIndex;
|
|
|
|
foreach (BandDesignIntf* band, childBands()) {
|
|
int newIndex = band->bandIndex() + indexOffset;
|
|
band->changeBandIndex(newIndex);
|
|
}
|
|
setBandIndex(value);
|
|
}
|
|
|
|
bool BandDesignIntf::isUnique() const { return true; }
|
|
|
|
void BandDesignIntf::setItemMode(BaseDesignIntf::ItemMode mode)
|
|
{
|
|
ItemsContainerDesignInft::setItemMode(mode);
|
|
updateBandMarkerGeometry();
|
|
}
|
|
|
|
QString BandDesignIntf::datasourceName() { return m_dataSourceName; }
|
|
|
|
void BandDesignIntf::setDataSourceName(const QString& datasource) { m_dataSourceName = datasource; }
|
|
|
|
void BandDesignIntf::setKeepBottomSpace(bool value)
|
|
{
|
|
if (m_keepBottomSpace != value) {
|
|
m_keepBottomSpace = value;
|
|
if (!isLoading())
|
|
notify("keepBottomSpace", !value, value);
|
|
}
|
|
}
|
|
|
|
void BandDesignIntf::addChildBand(BandDesignIntf* band)
|
|
{
|
|
m_childBands.append(band);
|
|
connect(band, SIGNAL(destroyed(QObject*)), this, SLOT(childBandDeleted(QObject*)));
|
|
}
|
|
|
|
void BandDesignIntf::removeChildBand(BandDesignIntf* band)
|
|
{
|
|
m_childBands.removeAt(m_childBands.indexOf(band));
|
|
}
|
|
|
|
void BandDesignIntf::setParentBand(BandDesignIntf* band)
|
|
{
|
|
m_parentBand = band;
|
|
if (band) {
|
|
if (parentBandName().compare(band->objectName(), Qt::CaseInsensitive) != 0)
|
|
setParentBandName(band->objectName());
|
|
band->addChildBand(this);
|
|
}
|
|
}
|
|
|
|
void BandDesignIntf::setParentBandName(const QString& parentBandName)
|
|
{
|
|
m_parentBandName = parentBandName;
|
|
if (itemMode() & DesignMode && !m_parentBandName.isEmpty()) {
|
|
if ((parentBand() == 0) || (parentBand()->objectName() != parentBandName))
|
|
setParentBand(findParentBand());
|
|
}
|
|
}
|
|
|
|
QString BandDesignIntf::parentBandName()
|
|
{
|
|
if (!m_parentBand)
|
|
return m_parentBandName;
|
|
else
|
|
return m_parentBand->objectName();
|
|
}
|
|
|
|
bool BandDesignIntf::isConnectedToBand(BandDesignIntf::BandsType bandType) const
|
|
{
|
|
foreach (BandDesignIntf* band, childBands())
|
|
if (band->bandType() == bandType)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
int BandDesignIntf::maxChildIndex(BandDesignIntf::BandsType bandType) const
|
|
{
|
|
int curIndex = bandIndex();
|
|
foreach (BandDesignIntf* childBand, childBands()) {
|
|
if ((childBand->bandIndex() > bandIndex()) && (childBand->bandType() < bandType)) {
|
|
curIndex = std::max(curIndex, childBand->maxChildIndex());
|
|
}
|
|
}
|
|
return curIndex;
|
|
}
|
|
|
|
int BandDesignIntf::maxChildIndex(QSet<BandDesignIntf::BandsType> ignoredBands) const
|
|
{
|
|
int curIndex = bandIndex();
|
|
foreach (BandDesignIntf* childBand, childBands()) {
|
|
if (!ignoredBands.contains(childBand->bandType())) {
|
|
curIndex = std::max(curIndex, childBand->maxChildIndex(ignoredBands));
|
|
}
|
|
}
|
|
return curIndex;
|
|
}
|
|
|
|
int BandDesignIntf::rootIndex(BandDesignIntf* parentBand)
|
|
{
|
|
return rootBand(parentBand)->bandIndex();
|
|
}
|
|
|
|
BandDesignIntf* BandDesignIntf::rootBand(BandDesignIntf* parentBand)
|
|
{
|
|
BandDesignIntf* currentBand = this;
|
|
while (currentBand->parentBand() && currentBand->parentBand() != parentBand)
|
|
currentBand = currentBand->parentBand();
|
|
return currentBand;
|
|
}
|
|
|
|
int BandDesignIntf::minChildIndex(BandDesignIntf::BandsType bandType)
|
|
{
|
|
int curIndex = bandIndex();
|
|
foreach (BandDesignIntf* childBand, childBands()) {
|
|
if (curIndex > childBand->bandIndex() && (childBand->bandType() > bandType)) {
|
|
curIndex = childBand->bandIndex();
|
|
}
|
|
}
|
|
return curIndex;
|
|
}
|
|
|
|
int BandDesignIntf::minChildIndex(QSet<BandDesignIntf::BandsType> ignoredBands)
|
|
{
|
|
int curIndex = bandIndex();
|
|
foreach (BandDesignIntf* childBand, childBands()) {
|
|
if (!ignoredBands.contains(childBand->bandType()) && childBand->bandIndex() < bandIndex()) {
|
|
curIndex = std::min(curIndex, childBand->minChildIndex(ignoredBands));
|
|
}
|
|
}
|
|
return curIndex;
|
|
}
|
|
|
|
QList<BandDesignIntf*> BandDesignIntf::childrenByType(BandDesignIntf::BandsType type)
|
|
{
|
|
QList<BandDesignIntf*> resList;
|
|
foreach (BandDesignIntf* item, childBands()) {
|
|
if (item->bandType() == type)
|
|
resList << item;
|
|
}
|
|
std::sort(resList.begin(), resList.end(), bandIndexLessThen);
|
|
return resList;
|
|
}
|
|
|
|
bool BandDesignIntf::canBeSplitted(int height) const
|
|
{
|
|
if (isSplittable()) {
|
|
foreach (QGraphicsItem* qgItem, childItems()) {
|
|
BaseDesignIntf* item = dynamic_cast<BaseDesignIntf*>(qgItem);
|
|
if (item)
|
|
if ((item->minHeight() > height) && (item->minHeight() > (this->height() - height)))
|
|
return false;
|
|
}
|
|
}
|
|
return isSplittable();
|
|
}
|
|
|
|
bool BandDesignIntf::isEmpty() const
|
|
{
|
|
if (!isVisible())
|
|
return true;
|
|
foreach (QGraphicsItem* qgItem, childItems()) {
|
|
BaseDesignIntf* item = dynamic_cast<BaseDesignIntf*>(qgItem);
|
|
if ((item) && (!item->isEmpty()))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool BandDesignIntf::isNeedRender() const { return true; }
|
|
|
|
void BandDesignIntf::setTryToKeepTogether(bool value)
|
|
{
|
|
if (m_tryToKeepTogether != value) {
|
|
m_tryToKeepTogether = value;
|
|
if (!isLoading())
|
|
notify("keepSubdetailTogether", !value, value);
|
|
}
|
|
}
|
|
|
|
bool BandDesignIntf::tryToKeepTogether() { return m_tryToKeepTogether; }
|
|
|
|
void BandDesignIntf::checkEmptyTable()
|
|
{
|
|
bool isEmpty = true;
|
|
bool allItemsIsText = true;
|
|
foreach (QGraphicsItem* qgItem, childItems()) {
|
|
BaseDesignIntf* item = dynamic_cast<BaseDesignIntf*>(qgItem);
|
|
if (item && !item->isEmpty())
|
|
isEmpty = false;
|
|
if (!item)
|
|
allItemsIsText = false;
|
|
}
|
|
if (isEmpty && allItemsIsText) {
|
|
foreach (QGraphicsItem* qgItem, childItems()) {
|
|
ContentItemDesignIntf* item = dynamic_cast<ContentItemDesignIntf*>(qgItem);
|
|
item->setHeight(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void BandDesignIntf::setColumnsCount(int value)
|
|
{
|
|
if (m_columnsCount != value && value > 0) {
|
|
qreal oldValue = m_columnsCount;
|
|
qreal fullWidth = m_columnsCount * width();
|
|
m_columnsCount = value;
|
|
if (!isLoading()) {
|
|
setWidth(fullWidth / m_columnsCount);
|
|
notify("columnsCount", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
void BandDesignIntf::setColumnsFillDirection(BandDesignIntf::BandColumnsLayoutType value)
|
|
{
|
|
if (m_columnsFillDirection != value) {
|
|
qreal oldValue = m_columnsFillDirection;
|
|
m_columnsFillDirection = value;
|
|
if (!isLoading())
|
|
notify("columnsFillDirection", oldValue, value);
|
|
}
|
|
}
|
|
|
|
void BandDesignIntf::moveItemsDown(qreal startPos, qreal offset)
|
|
{
|
|
foreach (QGraphicsItem* item, childItems()) {
|
|
if (item->pos().y() >= startPos)
|
|
item->setPos(item->x(), item->y() + offset);
|
|
}
|
|
}
|
|
|
|
void BandDesignIntf::preparePopUpMenu(QMenu& menu)
|
|
{
|
|
|
|
QList<QString> disabledActions;
|
|
disabledActions << tr("Bring to top") << tr("Send to back") << tr("Cut") << tr("Copy");
|
|
|
|
foreach (QAction* action, menu.actions()) {
|
|
action->setEnabled(!disabledActions.contains(action->text()));
|
|
}
|
|
|
|
menu.addSeparator();
|
|
QAction* currAction = menu.addAction(tr("Auto height"));
|
|
currAction->setCheckable(true);
|
|
currAction->setChecked(autoHeight());
|
|
|
|
currAction = menu.addAction(tr("Splittable"));
|
|
currAction->setEnabled(metaObject()->indexOfProperty("splittable") != -1);
|
|
currAction->setCheckable(true);
|
|
currAction->setChecked(isSplittable());
|
|
|
|
currAction = menu.addAction(tr("Keep top space"));
|
|
currAction->setCheckable(true);
|
|
currAction->setChecked(keepTopSpace());
|
|
|
|
currAction = menu.addAction(tr("Keep bottom space"));
|
|
currAction->setCheckable(true);
|
|
currAction->setChecked(keepBottomSpace());
|
|
|
|
currAction = menu.addAction(tr("Print if empty"));
|
|
currAction->setCheckable(true);
|
|
currAction->setChecked(printIfEmpty());
|
|
}
|
|
|
|
void BandDesignIntf::processPopUpAction(QAction* action)
|
|
{
|
|
if (action->text().compare(tr("Auto height")) == 0) {
|
|
setProperty("autoHeight", action->isChecked());
|
|
}
|
|
|
|
if (action->text().compare(tr("Splittable")) == 0) {
|
|
setProperty("splittable", action->isChecked());
|
|
}
|
|
|
|
if (action->text().compare(tr("Keep top space")) == 0) {
|
|
setProperty("keepTopSpace", action->isChecked());
|
|
}
|
|
|
|
if (action->text().compare(tr("Keep bottom space")) == 0) {
|
|
setProperty("keepBottomSpace", action->isChecked());
|
|
}
|
|
if (action->text().compare(tr("Keep top space")) == 0) {
|
|
setProperty("keepTopSpace", action->isChecked());
|
|
}
|
|
|
|
if (action->text().compare(tr("Print if empty")) == 0) {
|
|
setProperty("printIfEmpty", action->isChecked());
|
|
}
|
|
ItemsContainerDesignInft::processPopUpAction(action);
|
|
}
|
|
|
|
BaseDesignIntf* BandDesignIntf::cloneUpperPart(int height, QObject* owner, QGraphicsItem* parent)
|
|
{
|
|
int maxBottom = 0;
|
|
BandDesignIntf* upperPart = dynamic_cast<BandDesignIntf*>(createSameTypeItem(owner, parent));
|
|
BaseDesignIntf* upperItem = 0;
|
|
|
|
upperPart->initFromItem(this);
|
|
|
|
foreach (QGraphicsItem* qgItem, childItems()) {
|
|
BaseDesignIntf* item = dynamic_cast<BaseDesignIntf*>(qgItem);
|
|
if (item) {
|
|
if (item->geometry().bottom() <= height) {
|
|
upperItem = item->cloneItem(item->itemMode(), upperPart, upperPart);
|
|
if (maxBottom < upperItem->geometry().bottom())
|
|
maxBottom = upperItem->geometry().bottom();
|
|
} else if ((item->geometry().top() < height) && (item->geometry().bottom() > height)) {
|
|
int sliceHeight = height - item->geometry().top();
|
|
if (!item->isSplittable()) {
|
|
if (sliceHeight > (this->height() - sliceHeight)) {
|
|
upperItem = item->cloneItem(item->itemMode(), upperPart, upperPart);
|
|
upperItem->setHeight(height);
|
|
} else {
|
|
item->cloneEmpty(sliceHeight, upperPart, upperPart); // for table
|
|
// qgItem->setPos(item->pos().x(),item->pos().y()+((height+1)-item->geometry().top()));
|
|
moveItemsDown(item->pos().y(), (height + 1) - item->geometry().top());
|
|
}
|
|
} else if (item->canBeSplitted(sliceHeight)) {
|
|
upperItem = item->cloneUpperPart(sliceHeight, upperPart, upperPart);
|
|
if (maxBottom < upperItem->geometry().bottom())
|
|
maxBottom = upperItem->geometry().bottom();
|
|
m_slicedItems.insert(upperItem->objectName(), upperItem);
|
|
} else {
|
|
item->cloneEmpty(sliceHeight, upperPart, upperPart); // for table
|
|
moveItemsDown(item->pos().y(), (height + 1) - item->geometry().top());
|
|
// qgItem->setPos(item->pos().x(),item->pos().y()+((height+1)-item->geometry().top()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
upperPart->setHeight(height);
|
|
return upperPart;
|
|
}
|
|
|
|
bool itemLessThen(QGraphicsItem* i1, QGraphicsItem* i2) { return i1->pos().y() < i2->pos().y(); }
|
|
|
|
BaseDesignIntf* BandDesignIntf::cloneBottomPart(int height, QObject* owner, QGraphicsItem* parent)
|
|
{
|
|
BandDesignIntf* bottomPart = dynamic_cast<BandDesignIntf*>(createSameTypeItem(owner, parent));
|
|
bottomPart->initFromItem(this);
|
|
|
|
QList<QGraphicsItem*> bandItems;
|
|
bandItems = childItems();
|
|
std::sort(bandItems.begin(), bandItems.end(), itemLessThen);
|
|
|
|
foreach (QGraphicsItem* qgItem, bandItems) {
|
|
BaseDesignIntf* item = dynamic_cast<BaseDesignIntf*>(qgItem);
|
|
|
|
if (item) {
|
|
if (item->geometry().top() > height) {
|
|
BaseDesignIntf* tmpItem = item->cloneItem(item->itemMode(), bottomPart, bottomPart);
|
|
tmpItem->setPos(tmpItem->pos().x(),
|
|
(tmpItem->pos().y() - height) + borderLineSize());
|
|
} else if ((item->geometry().top() <= height) && (item->geometry().bottom() > height)) {
|
|
int sliceHeight = height - item->geometry().top();
|
|
if (item->isSplittable() && item->canBeSplitted(sliceHeight)) {
|
|
BaseDesignIntf* tmpItem
|
|
= item->cloneBottomPart(sliceHeight, bottomPart, bottomPart);
|
|
tmpItem->setPos(tmpItem->pos().x(), borderLineSize());
|
|
BaseDesignIntf* slicedItem = m_slicedItems.value(tmpItem->objectName());
|
|
if (slicedItem) {
|
|
qreal sizeOffset
|
|
= (slicedItem->height() + tmpItem->height()) - item->height();
|
|
qreal bottomOffset = (height - slicedItem->pos().y())
|
|
- m_slicedItems.value(tmpItem->objectName())->height();
|
|
moveItemsDown(item->pos().y() + item->height(), sizeOffset + bottomOffset);
|
|
}
|
|
} else {
|
|
BaseDesignIntf* tmpItem
|
|
= item->cloneItem(item->itemMode(), bottomPart, bottomPart);
|
|
tmpItem->setPos(tmpItem->pos().x(), borderLineSize());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return bottomPart;
|
|
}
|
|
|
|
void BandDesignIntf::parentObjectLoadFinished()
|
|
{
|
|
if (!parentBandName().isEmpty())
|
|
setParentBand(findParentBand());
|
|
}
|
|
|
|
void BandDesignIntf::objectLoadFinished()
|
|
{
|
|
m_bandMarker->setHeight(height());
|
|
BaseDesignIntf::objectLoadFinished();
|
|
}
|
|
|
|
void BandDesignIntf::emitBandRendered(BandDesignIntf* band) { emit bandRendered(band); }
|
|
|
|
void BandDesignIntf::emitBandReRendered(BandDesignIntf* oldBand, BandDesignIntf* newBand)
|
|
{
|
|
emit bandReRendered(oldBand, newBand);
|
|
}
|
|
|
|
void BandDesignIntf::setSplittable(bool value)
|
|
{
|
|
if (m_splitable != value) {
|
|
bool oldValue = m_splitable;
|
|
m_splitable = value;
|
|
if (!isLoading())
|
|
notify("splittable", oldValue, value);
|
|
}
|
|
}
|
|
|
|
bool bandIndexLessThen(const BandDesignIntf* b1, const BandDesignIntf* b2)
|
|
{
|
|
return b1->bandIndex() < b2->bandIndex();
|
|
}
|
|
|
|
void BandDesignIntf::trimToMaxHeight(int maxHeight)
|
|
{
|
|
foreach (BaseDesignIntf* item, childBaseItems()) {
|
|
if (item->height() > maxHeight)
|
|
item->setHeight(maxHeight);
|
|
}
|
|
}
|
|
|
|
void BandDesignIntf::setBandTypeText(const QString& value)
|
|
{
|
|
m_bandTypeText = value;
|
|
m_bandNameLabel->updateLabel(bandTitle());
|
|
}
|
|
|
|
QSet<BandDesignIntf::BandsType> BandDesignIntf::groupBands()
|
|
{
|
|
QSet<BandDesignIntf::BandsType> result;
|
|
result << GroupHeader << GroupFooter;
|
|
return result;
|
|
}
|
|
|
|
QSet<BandDesignIntf::BandsType> BandDesignIntf::subdetailBands()
|
|
{
|
|
QSet<BandDesignIntf::BandsType> result;
|
|
result << SubDetailBand << SubDetailHeader << SubDetailFooter;
|
|
return result;
|
|
}
|
|
|
|
BandDesignIntf* BandDesignIntf::findParentBand()
|
|
{
|
|
if (parent() && (!dynamic_cast<BaseDesignIntf*>(parent())->isLoading())) {
|
|
foreach (QObject* item, parent()->children()) {
|
|
BandDesignIntf* band = dynamic_cast<BandDesignIntf*>(item);
|
|
if (band && (band->objectName().compare(parentBandName(), Qt::CaseInsensitive) == 0))
|
|
return band;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void BandDesignIntf::updateBandMarkerGeometry()
|
|
{
|
|
if (parentItem() && m_bandMarker) {
|
|
m_bandMarker->setPos(
|
|
pos().x() - m_bandMarker->width()
|
|
- (itemMode() == ItemModes::PrintMode ? boundingRect().width() : 0),
|
|
pos().y());
|
|
m_bandMarker->setHeight(rect().height());
|
|
}
|
|
}
|
|
|
|
void BandDesignIntf::geometryChangedEvent(QRectF, QRectF)
|
|
{
|
|
if (((itemMode() & DesignMode) || (itemMode() & EditMode)) && parentItem()) {
|
|
updateBandMarkerGeometry();
|
|
}
|
|
foreach (BaseDesignIntf* item, childBaseItems()) {
|
|
if (item->itemAlign() != DesignedItemAlign) {
|
|
item->updateItemAlign();
|
|
}
|
|
}
|
|
}
|
|
|
|
QVariant BandDesignIntf::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant& value)
|
|
{
|
|
if ((change == ItemPositionChange) && ((itemMode() & DesignMode) || (itemMode() & EditMode))) {
|
|
if (m_bandMarker) {
|
|
m_bandMarker->setPos(
|
|
(value.toPointF().x() - m_bandMarker->boundingRect().width()
|
|
- (itemMode() == ItemModes::PrintMode ? boundingRect().width() : 0)),
|
|
value.toPointF().y());
|
|
}
|
|
}
|
|
if (change == ItemSelectedChange) {
|
|
if (m_bandMarker) {
|
|
m_bandMarker->update(0, 0, m_bandMarker->boundingRect().width(),
|
|
m_bandMarker->boundingRect().width());
|
|
m_bandNameLabel->updateLabel(bandTitle());
|
|
m_bandNameLabel->setVisible(value.toBool());
|
|
}
|
|
}
|
|
if (change == ItemChildAddedChange || change == ItemChildRemovedChange) {
|
|
update(rect());
|
|
}
|
|
return BaseDesignIntf::itemChange(change, value);
|
|
}
|
|
|
|
void BandDesignIntf::initMode(ItemMode mode)
|
|
{
|
|
BaseDesignIntf::initMode(mode);
|
|
if ((mode == PreviewMode) || (mode == PrintMode)) {
|
|
m_bandMarker->setVisible(false);
|
|
} else {
|
|
if (!m_bandMarker->scene() && this->scene()) {
|
|
this->scene()->addItem(m_bandMarker);
|
|
m_bandMarker->setParentItem(this->parentItem());
|
|
m_bandMarker->setHeight(this->height());
|
|
}
|
|
m_bandMarker->setVisible(true);
|
|
}
|
|
}
|
|
|
|
QColor BandDesignIntf::bandColor() const { return Qt::darkBlue; }
|
|
|
|
void BandDesignIntf::setMarkerColor(QColor color)
|
|
{
|
|
if (m_bandMarker)
|
|
m_bandMarker->setColor(color);
|
|
}
|
|
|
|
void BandDesignIntf::childBandDeleted(QObject* band)
|
|
{
|
|
m_childBands.removeAt(m_childBands.indexOf(reinterpret_cast<BandDesignIntf*>(band)));
|
|
}
|
|
|
|
bool BandDesignIntf::useAlternateBackgroundColor() const { return m_useAlternateBackgroundColor; }
|
|
|
|
void BandDesignIntf::setUseAlternateBackgroundColor(bool useAlternateBackgroundColor)
|
|
{
|
|
if (m_useAlternateBackgroundColor != useAlternateBackgroundColor) {
|
|
QColor oldValue = m_useAlternateBackgroundColor;
|
|
m_useAlternateBackgroundColor = useAlternateBackgroundColor;
|
|
if (!isLoading())
|
|
notify("useAlternateBackgroundColor", oldValue, useAlternateBackgroundColor);
|
|
}
|
|
}
|
|
|
|
QColor BandDesignIntf::alternateBackgroundColor() const
|
|
{
|
|
if (metaObject()->indexOfProperty("alternateBackgroundColor") != -1)
|
|
return m_alternateBackgroundColor;
|
|
else
|
|
return backgroundColor();
|
|
}
|
|
|
|
void BandDesignIntf::setAlternateBackgroundColor(const QColor& alternateBackgroundColor)
|
|
{
|
|
if (m_alternateBackgroundColor != alternateBackgroundColor) {
|
|
QColor oldValue = m_alternateBackgroundColor;
|
|
m_alternateBackgroundColor = alternateBackgroundColor;
|
|
if (!isLoading())
|
|
notify("alternateBackgroundColor", oldValue, alternateBackgroundColor);
|
|
}
|
|
}
|
|
|
|
qreal BandDesignIntf::bottomSpace() { return m_bottomSpace; }
|
|
|
|
void BandDesignIntf::slotPropertyObjectNameChanged(const QString&, const QString& newName)
|
|
{
|
|
update();
|
|
if (m_bandNameLabel)
|
|
m_bandNameLabel->updateLabel(newName);
|
|
}
|
|
|
|
int BandDesignIntf::shiftItems() const { return m_shiftItems; }
|
|
|
|
void BandDesignIntf::setShiftItems(int shiftItems) { m_shiftItems = shiftItems; }
|
|
|
|
bool BandDesignIntf::keepTopSpace() const { return m_keepTopSpace; }
|
|
|
|
void BandDesignIntf::setKeepTopSpace(bool value)
|
|
{
|
|
if (m_keepTopSpace != value) {
|
|
m_keepTopSpace = value;
|
|
if (!isLoading())
|
|
notify("keepTopSpace", !value, value);
|
|
}
|
|
}
|
|
|
|
void BandDesignIntf::setBottomSpace(qreal bottomSpace) { m_bottomSpace = bottomSpace; }
|
|
|
|
bool BandDesignIntf::repeatOnEachRow() const { return m_repeatOnEachRow; }
|
|
|
|
void BandDesignIntf::setRepeatOnEachRow(bool repeatOnEachRow)
|
|
{
|
|
if (m_repeatOnEachRow != repeatOnEachRow) {
|
|
m_repeatOnEachRow = repeatOnEachRow;
|
|
if (!isLoading())
|
|
notify("repeatOnEachRow", !m_repeatOnEachRow, m_repeatOnEachRow);
|
|
}
|
|
}
|
|
|
|
bool BandDesignIntf::printAlways() const { return m_printAlways; }
|
|
|
|
void BandDesignIntf::setPrintAlways(bool printAlways)
|
|
{
|
|
if (m_printAlways != printAlways) {
|
|
m_printAlways = printAlways;
|
|
if (!isLoading())
|
|
notify("printAlways", !m_printAlways, m_printAlways);
|
|
}
|
|
}
|
|
|
|
bool BandDesignIntf::startFromNewPage() const { return m_startFromNewPage; }
|
|
|
|
void BandDesignIntf::setStartFromNewPage(bool startWithNewPage)
|
|
{
|
|
if (m_startFromNewPage != startWithNewPage) {
|
|
m_startFromNewPage = startWithNewPage;
|
|
if (!isLoading())
|
|
notify("startFromNewPage", !startWithNewPage, startWithNewPage);
|
|
}
|
|
}
|
|
|
|
bool BandDesignIntf::startNewPage() const { return m_startNewPage; }
|
|
|
|
void BandDesignIntf::setStartNewPage(bool startNewPage)
|
|
{
|
|
if (m_startNewPage != startNewPage) {
|
|
m_startNewPage = startNewPage;
|
|
if (!isLoading())
|
|
notify("startNewPage", !startNewPage, startNewPage);
|
|
}
|
|
}
|
|
|
|
void BandDesignIntf::setAutoHeight(bool value)
|
|
{
|
|
if (m_autoHeight != value) {
|
|
m_autoHeight = value;
|
|
if (!isLoading())
|
|
notify("autoHeight", !value, value);
|
|
}
|
|
}
|
|
|
|
bool BandDesignIntf::reprintOnEachPage() const { return m_reprintOnEachPage; }
|
|
|
|
void BandDesignIntf::setReprintOnEachPage(bool reprintOnEachPage)
|
|
{
|
|
if (m_reprintOnEachPage != reprintOnEachPage) {
|
|
m_reprintOnEachPage = reprintOnEachPage;
|
|
if (!isLoading())
|
|
notify("reprintOnEachPage", !m_reprintOnEachPage, m_reprintOnEachPage);
|
|
}
|
|
}
|
|
|
|
int BandDesignIntf::columnIndex() const { return m_columnIndex; }
|
|
|
|
void BandDesignIntf::setColumnIndex(int columnIndex) { m_columnIndex = columnIndex; }
|
|
|
|
bool BandDesignIntf::printIfEmpty() const { return m_printIfEmpty; }
|
|
|
|
void BandDesignIntf::setPrintIfEmpty(bool printIfEmpty)
|
|
{
|
|
if (m_printIfEmpty != printIfEmpty) {
|
|
m_printIfEmpty = printIfEmpty;
|
|
if (!isLoading())
|
|
notify("printIfEmpty", !m_printIfEmpty, m_printIfEmpty);
|
|
}
|
|
}
|
|
|
|
BandDesignIntf* BandDesignIntf::bandHeader()
|
|
{
|
|
foreach (BandDesignIntf* band, childBands()) {
|
|
if (band->isHeader() && !band->isGroupHeader()) {
|
|
if (band->columnsCount() > 1)
|
|
band->setColumnsFillDirection(this->columnsFillDirection());
|
|
return band;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
BandDesignIntf* BandDesignIntf::bandFooter()
|
|
{
|
|
foreach (BandDesignIntf* band, childBands()) {
|
|
if (band->isFooter())
|
|
return band;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool BandDesignIntf::sliceLastRow() const { return m_sliceLastRow; }
|
|
|
|
void BandDesignIntf::setSliceLastRow(bool sliceLastRow)
|
|
{
|
|
if (m_sliceLastRow != sliceLastRow) {
|
|
m_sliceLastRow = sliceLastRow;
|
|
if (!isLoading())
|
|
notify("sliceLastRow", !sliceLastRow, sliceLastRow);
|
|
}
|
|
}
|
|
|
|
int BandDesignIntf::maxScalePercent() const { return m_maxScalePercent; }
|
|
|
|
void BandDesignIntf::setMaxScalePercent(int maxScalePercent)
|
|
{
|
|
m_maxScalePercent = maxScalePercent;
|
|
}
|
|
|
|
bool BandDesignIntf::keepFooterTogether() const { return m_keepFooterTogether; }
|
|
|
|
void BandDesignIntf::setKeepFooterTogether(bool value)
|
|
{
|
|
if (m_keepFooterTogether != value) {
|
|
bool oldValue = m_keepFooterTogether;
|
|
m_keepFooterTogether = value;
|
|
if (!isLoading())
|
|
notify("keepFooterTogether", oldValue, value);
|
|
}
|
|
}
|
|
|
|
void BandDesignIntf::updateItemSize(DataSourceManager* dataManager, RenderPass pass, int maxHeight)
|
|
{
|
|
qreal spaceBorder = 0;
|
|
if (keepBottomSpace())
|
|
spaceBorder = bottomSpace();
|
|
spaceBorder = spaceBorder > 0 ? spaceBorder : 0;
|
|
if (borderLines() != 0) {
|
|
spaceBorder += borderLineSize() + 2;
|
|
}
|
|
|
|
restoreLinks();
|
|
snapshotItemsLayout();
|
|
|
|
arrangeSubItems(pass, dataManager);
|
|
if (autoHeight()) {
|
|
if (!keepTopSpace()) {
|
|
qreal minTop = findMinTop() + m_shiftItems;
|
|
foreach (BaseDesignIntf* item, childBaseItems()) {
|
|
item->setY(item->y() - minTop);
|
|
}
|
|
}
|
|
setHeight(findMaxBottom() + spaceBorder);
|
|
}
|
|
if ((maxHeight > 0) && (height() > maxHeight)) {
|
|
trimToMaxHeight(maxHeight);
|
|
setHeight(maxHeight);
|
|
}
|
|
BaseDesignIntf::updateItemSize(dataManager, pass, maxHeight);
|
|
}
|
|
|
|
void BandDesignIntf::updateBandNameLabel()
|
|
{
|
|
if (m_bandNameLabel)
|
|
m_bandNameLabel->updateLabel(bandTitle());
|
|
}
|
|
|
|
void BandDesignIntf::initFromItem(BaseDesignIntf* source)
|
|
{
|
|
ItemsContainerDesignInft::initFromItem(source);
|
|
BandDesignIntf* source_band = dynamic_cast<BandDesignIntf*>(source);
|
|
if (source_band) {
|
|
this->setBottomSpace(source_band->bottomSpace());
|
|
}
|
|
}
|
|
|
|
QColor BandDesignIntf::selectionColor() const { return Qt::yellow; }
|
|
|
|
DataBandDesignIntf::DataBandDesignIntf(BandDesignIntf::BandsType bandType, QString xmlTypeName,
|
|
QObject* owner, QGraphicsItem* parent):
|
|
BandDesignIntf(bandType, xmlTypeName, owner, parent)
|
|
{
|
|
}
|
|
|
|
BandNameLabel::BandNameLabel(BandDesignIntf* band, QGraphicsItem* parent):
|
|
QGraphicsItem(parent),
|
|
m_rect(5, 5, 30, 30),
|
|
m_band(band)
|
|
{
|
|
setAcceptHoverEvents(true);
|
|
}
|
|
|
|
void BandNameLabel::paint(QPainter* painter, const QStyleOptionGraphicsItem* option,
|
|
QWidget* widget)
|
|
{
|
|
painter->save();
|
|
painter->setRenderHint(QPainter::Antialiasing);
|
|
painter->setFont(QFont("Arial", 7 * Const::fontFACTOR, -1, true));
|
|
painter->setOpacity(1);
|
|
QPen pen(Const::BAND_NAME_BORDER_COLOR);
|
|
// pen.setWidth(2);
|
|
painter->setBrush(Qt::yellow);
|
|
painter->setPen(pen);
|
|
painter->drawRoundedRect(m_rect, 8, 8);
|
|
painter->setOpacity(0.8);
|
|
painter->setPen(Qt::black);
|
|
painter->drawText(m_rect, Qt::AlignCenter, m_band->bandTitle());
|
|
painter->restore();
|
|
Q_UNUSED(option)
|
|
Q_UNUSED(widget)
|
|
}
|
|
|
|
QRectF BandNameLabel::boundingRect() const { return m_rect; }
|
|
|
|
void BandNameLabel::updateLabel(const QString& bandName)
|
|
{
|
|
QFont font("Arial", 7 * Const::fontFACTOR, -1, true);
|
|
QFontMetrics fontMetrics(font);
|
|
prepareGeometryChange();
|
|
m_rect = QRectF(m_band->pos().x() + 10, m_band->pos().y() - (fontMetrics.height() + 10),
|
|
fontMetrics.boundingRect(bandName).width() + 20, fontMetrics.height() + 10);
|
|
update();
|
|
}
|
|
|
|
void BandNameLabel::hoverEnterEvent(QGraphicsSceneHoverEvent* event)
|
|
{
|
|
setVisible(false);
|
|
Q_UNUSED(event)
|
|
}
|
|
|
|
} // namespace LimeReport
|