0
0
mirror of https://github.com/fralx/LimeReport.git synced 2024-12-24 16:44:39 +03:00
LimeReport/limereport/items/lrhorizontallayout.cpp
Андрей Лухнов 0fca7169d3 Define code style and format all source file using clang-format-14
except those placed in 3rdparty directories.
2024-09-19 21:09:38 +03:00

253 lines
9.5 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 "lrhorizontallayout.h"
#include "lrbasedesignintf.h"
#include "lrdesignelementsfactory.h"
#include <QDebug>
#include <QGraphicsScene>
#include <QGraphicsSceneMouseEvent>
#include <QObject>
const QString xmlTag = "HLayout";
namespace {
LimeReport::BaseDesignIntf* createHLayout(QObject* owner, LimeReport::BaseDesignIntf* parent)
{
return new LimeReport::HorizontalLayout(owner, parent);
}
bool VARIABLE_IS_NOT_USED registred = LimeReport::DesignElementsFactory::instance().registerCreator(
xmlTag, LimeReport::ItemAttribs(QObject::tr("HLayout"), LimeReport::Const::bandTAG),
createHLayout);
} // namespace
namespace LimeReport {
bool horizontalLessThen(BaseDesignIntf* c1, BaseDesignIntf* c2)
{
return c1->pos().x() < c2->pos().x();
}
HorizontalLayout::HorizontalLayout(QObject* owner, QGraphicsItem* parent):
AbstractLayout(xmlTag, owner, parent)
{
}
HorizontalLayout::~HorizontalLayout() { }
BaseDesignIntf* HorizontalLayout::createSameTypeItem(QObject* owner, QGraphicsItem* parent)
{
return new LimeReport::HorizontalLayout(owner, parent);
}
bool HorizontalLayout::canBeSplitted(int height) const
{
foreach (QGraphicsItem* qgItem, childItems()) {
BaseDesignIntf* item = dynamic_cast<BaseDesignIntf*>(qgItem);
if (item)
if (!item->canBeSplitted(height - item->pos().y()))
return false;
}
return true;
}
BaseDesignIntf* HorizontalLayout::cloneUpperPart(int height, QObject* owner, QGraphicsItem* parent)
{
HorizontalLayout* upperPart
= dynamic_cast<HorizontalLayout*>(createSameTypeItem(owner, parent));
upperPart->initFromItem(this);
qreal maxHeight = 0;
foreach (BaseDesignIntf* item, childBaseItems()) {
if ((item->geometry().top() < height) && (item->geometry().bottom() > height)) {
int sliceHeight = height - item->geometry().top();
if (item->canBeSplitted(sliceHeight)) {
BaseDesignIntf* slicedPart
= item->cloneUpperPart(sliceHeight, upperPart, upperPart);
if (maxHeight < slicedPart->height())
maxHeight = slicedPart->height();
} else {
item->cloneEmpty(sliceHeight, upperPart, upperPart);
item->setPos(item->pos().x(),
item->pos().y() + ((height + 1) - item->geometry().top()));
}
}
}
foreach (BaseDesignIntf* item, upperPart->childBaseItems()) {
item->setHeight((maxHeight < height) ? maxHeight : height);
}
upperPart->setHeight(height);
return upperPart;
}
BaseDesignIntf* HorizontalLayout::cloneBottomPart(int height, QObject* owner, QGraphicsItem* parent)
{
qreal maxHeight = 0;
HorizontalLayout* bottomPart
= dynamic_cast<HorizontalLayout*>(createSameTypeItem(owner, parent));
bottomPart->initFromItem(this);
foreach (BaseDesignIntf* item, childBaseItems()) {
if ((item->geometry().top() < height) && (item->geometry().bottom() > height)) {
BaseDesignIntf* tmpItem = item->cloneBottomPart(height, bottomPart, bottomPart);
tmpItem->setPos(tmpItem->pos().x(), 0);
if (maxHeight < tmpItem->height())
maxHeight = tmpItem->height();
}
}
if (!bottomPart->isEmpty()) {
foreach (BaseDesignIntf* item, bottomPart->childBaseItems()) {
item->setHeight(maxHeight);
}
bottomPart->setHeight(maxHeight);
}
return bottomPart;
}
void HorizontalLayout::setItemAlign(const BaseDesignIntf::ItemAlign& itemAlign)
{
if (itemAlign == ParentWidthItemAlign)
setLayoutType(Table);
BaseDesignIntf::setItemAlign(itemAlign);
}
void HorizontalLayout::sortChildren()
{
std::sort(layoutsChildren().begin(), layoutsChildren().end(), horizontalLessThen);
}
void HorizontalLayout::updateLayoutSize()
{
int spaceBorder = (borderLines() != 0) ? borderLineSize() : 0;
qreal w = spaceBorder * 2;
qreal h = 0;
int visibleItemCount = 0;
foreach (BaseDesignIntf* item, layoutsChildren()) {
if (item->isEmpty() && hideEmptyItems())
item->setVisible(false);
if (item->isVisible()) {
if (h < item->height())
h = item->height();
w += item->width();
visibleItemCount++;
}
}
if (h > 0)
setHeight(h + spaceBorder * 2);
if (layoutType() == Layout)
setWidth(w + layoutSpacingMM() * (visibleItemCount - 1));
else {
relocateChildren();
if (!isRelocating()) {
divideSpace();
}
}
}
void HorizontalLayout::relocateChildren()
{
int spaceBorder = (borderLines() != 0) ? borderLineSize() : 0;
QList<BaseDesignIntf*> newChildren;
if (layoutsChildren().count() < childItems().size() - 1) {
auto oldChildren = layoutsChildren();
layoutsChildren().clear();
foreach (BaseDesignIntf* item, childBaseItems()) {
if (!oldChildren.contains(item)) {
newChildren.append(item);
}
layoutsChildren().append(item);
}
}
std::sort(layoutsChildren().begin(), layoutsChildren().end(), horizontalLessThen);
qreal curX = spaceBorder;
setIsRelocating(true);
foreach (BaseDesignIntf* item, layoutsChildren()) {
if (item->isVisible() || itemMode() == DesignMode) {
item->setPos(curX, spaceBorder);
curX += item->width() + layoutSpacingMM();
item->setHeight(height() - (spaceBorder * 2));
}
}
setIsRelocating(false);
for (BaseDesignIntf* item : newChildren) {
connectToLayout(item);
}
}
void HorizontalLayout::divideSpace()
{
setIsRelocating(true);
qreal itemsSumSize = 0;
int visibleItemsCount = 0;
int spaceBorder = (borderLines() != 0) ? borderLineSize() : 0;
foreach (BaseDesignIntf* item, layoutsChildren()) {
if (item->isVisible() || itemMode() == DesignMode) {
itemsSumSize += item->width();
visibleItemsCount++;
}
}
itemsSumSize += layoutSpacingMM() * (visibleItemsCount - 1);
if (itemMode() == DesignMode && !layoutsChildren().isEmpty()) {
qreal delta = (width() - (itemsSumSize + spaceBorder * 2));
layoutsChildren().last()->setWidth(layoutsChildren().last()->width() + delta);
} else {
qreal delta = (width() - (itemsSumSize + spaceBorder * 2))
/ (visibleItemsCount != 0 ? visibleItemsCount : 1);
for (int i = 0; i < layoutsChildren().size(); ++i) {
if (layoutsChildren()[i]->isVisible() || itemMode() == DesignMode)
layoutsChildren()[i]->setWidth(layoutsChildren()[i]->width() + delta);
if ((i + 1) < layoutsChildren().size())
if (layoutsChildren()[i + 1]->isVisible() || itemMode() == DesignMode)
layoutsChildren()[i + 1]->setPos(layoutsChildren()[i + 1]->pos().x()
+ delta * (i + 1),
layoutsChildren()[i + 1]->pos().y());
}
}
setIsRelocating(false);
}
void HorizontalLayout::placeItemInLayout(BaseDesignIntf* item)
{
if (layoutsChildren().count() > 0)
item->setPos(layoutsChildren().last()->pos().x() + layoutsChildren().last()->width(), 0);
else
item->setPos(0, 0);
}
} // namespace LimeReport