mirror of
https://github.com/fralx/LimeReport.git
synced 2025-03-14 22:33:48 +03:00
1074 lines
33 KiB
C++
1074 lines
33 KiB
C++
/***************************************************************************
|
|
* This file is part of the Lime Report project *
|
|
* Copyright (C) 2015 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 "lritemdesignintf.h"
|
|
#include "lrglobal.h"
|
|
#include <algorithm>
|
|
#include <QGraphicsScene>
|
|
#include <QGraphicsSceneMouseEvent>
|
|
#include <QMenu>
|
|
|
|
namespace LimeReport {
|
|
|
|
BandMarker::BandMarker(BandDesignIntf *band, QGraphicsItem* parent)
|
|
:QGraphicsItem(parent),m_rect(0,0,30,30),m_band(band)
|
|
{}
|
|
|
|
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->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);
|
|
update(0,0,boundingRect().width(),boundingRect().width());
|
|
}
|
|
}
|
|
|
|
void BandMarker::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
|
|
{
|
|
m_band->contextMenuEvent(event);
|
|
}
|
|
|
|
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_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_bottomSpace(0)
|
|
{
|
|
setPossibleResizeDirectionFlags(ResizeBottom);
|
|
setPossibleMoveFlags(TopBotom);
|
|
|
|
if (parent) {
|
|
BaseDesignIntf* parentItem = dynamic_cast<BaseDesignIntf*>(parent);
|
|
if (parentItem) setWidth(parentItem->width());
|
|
}
|
|
|
|
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(),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()
|
|
{
|
|
// if (itemMode()&DesignMode){
|
|
// foreach(BandDesignIntf* band,childBands()) {
|
|
// removeChildBand(band);
|
|
// delete band;
|
|
// }
|
|
// }
|
|
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);
|
|
}
|
|
}
|
|
|
|
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.width(" "+bandText+" "),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);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
QString BandDesignIntf::datasourceName(){
|
|
return m_dataSourceName;
|
|
}
|
|
|
|
void BandDesignIntf::setDataSourceName(const QString &datasource){
|
|
m_dataSourceName=datasource;
|
|
}
|
|
|
|
void BandDesignIntf::setKeepBottomSpaceOption(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::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->maxChildIndex(ignoredBands));
|
|
}
|
|
}
|
|
return curIndex;
|
|
}
|
|
|
|
|
|
|
|
QList<BandDesignIntf *> BandDesignIntf::childrenByType(BandDesignIntf::BandsType type)
|
|
{
|
|
QList<BandDesignIntf*> resList;
|
|
foreach(BandDesignIntf* item,childBands()){
|
|
if (item->bandType()==type) resList<<item;
|
|
}
|
|
qSort(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 bottom space"));
|
|
currAction->setCheckable(true);
|
|
currAction->setChecked(keepBottomSpaceOption());
|
|
|
|
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 bottom space")) == 0){
|
|
setProperty("keepBottomSpace",action->isChecked());
|
|
}
|
|
if (action->text().compare(tr("Print if empty")) == 0){
|
|
setProperty("printIfEmpty",action->isChecked());
|
|
}
|
|
|
|
}
|
|
|
|
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);
|
|
height = maxBottom;
|
|
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 {
|
|
if ((item->geometry().bottom()-height)>=height){
|
|
BaseDesignIntf* tmpItem = item->cloneItem(item->itemMode(),bottomPart,bottomPart);
|
|
tmpItem->setPos(tmpItem->pos().x(),borderLineSize());
|
|
tmpItem->setHeight((this->height()-height));
|
|
} else {
|
|
BaseDesignIntf* tmpItem = item->cloneEmpty((this->height()-height),bottomPart,bottomPart);
|
|
if (tmpItem)
|
|
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::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::geometryChangedEvent(QRectF, QRectF )
|
|
{
|
|
if (((itemMode()&DesignMode) || (itemMode()&EditMode))&&parentItem()){
|
|
QPointF sp = parentItem()->mapToScene(pos());
|
|
if (m_bandMarker){
|
|
m_bandMarker->setPos((sp.x()-m_bandMarker->boundingRect().width()),sp.y());
|
|
m_bandMarker->setHeight(rect().height());
|
|
}
|
|
}
|
|
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()),
|
|
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)));
|
|
}
|
|
|
|
QColor BandDesignIntf::alternateBackgroundColor() const
|
|
{
|
|
if (metaObject()->indexOfProperty("alternateBackgroundColor")!=-1)
|
|
return m_alternateBackgroundColor;
|
|
else
|
|
return backgroundColor();
|
|
}
|
|
|
|
void BandDesignIntf::setAlternateBackgroundColor(const QColor &alternateBackgroundColor)
|
|
{
|
|
m_alternateBackgroundColor = alternateBackgroundColor;
|
|
}
|
|
|
|
qreal BandDesignIntf::bottomSpace() const
|
|
{
|
|
return height()-findMaxBottom();
|
|
}
|
|
|
|
void BandDesignIntf::slotPropertyObjectNameChanged(const QString &, const QString& newName)
|
|
{
|
|
update();
|
|
if (m_bandNameLabel)
|
|
m_bandNameLabel->updateLabel(newName);
|
|
}
|
|
|
|
int BandDesignIntf::bootomSpace() const
|
|
{
|
|
return m_bottomSpace;
|
|
}
|
|
|
|
void BandDesignIntf::setBootomSpace(int bootomSpace)
|
|
{
|
|
m_bottomSpace = bootomSpace;
|
|
}
|
|
|
|
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 (keepBottomSpaceOption()) spaceBorder = bottomSpace();
|
|
spaceBorder = spaceBorder>0 ? spaceBorder : 0;
|
|
if (borderLines()!=0){
|
|
spaceBorder += borderLineSize();
|
|
}
|
|
|
|
spaceBorder += m_bottomSpace;
|
|
restoreLinks();
|
|
snapshotItemsLayout();
|
|
arrangeSubItems(pass, dataManager);
|
|
if (autoHeight()){
|
|
//if keepBottomSpace()&& height()<findMaxBottom()
|
|
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());
|
|
}
|
|
|
|
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.width(bandName)+20,fontMetrics.height()+10
|
|
);
|
|
update();
|
|
}
|
|
|
|
void BandNameLabel::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
|
|
{
|
|
setVisible(false);
|
|
Q_UNUSED(event)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|