LimeReport/limereport/items/lrabstractlayout.cpp

383 lines
10 KiB
C++
Raw Normal View History

2018-06-21 14:29:00 +03:00
#include "lrabstractlayout.h"
namespace LimeReport {
AbstractLayout::AbstractLayout(QString xmlTag, QObject* owner, QGraphicsItem* parent)
: LayoutDesignIntf(xmlTag, owner, parent), m_isRelocating(false), m_layoutType(Layout),
m_hideEmptyItems(false), m_layoutSpacing(0)
2018-06-21 14:29:00 +03:00
{
setPossibleResizeDirectionFlags(AllDirections);
m_layoutMarker = new LayoutMarker(this);
m_layoutMarker->setParentItem(this);
m_layoutMarker->setColor(Qt::red);
m_layoutMarker->setHeight(height());
m_layoutMarker->setZValue(1);
}
AbstractLayout::~AbstractLayout()
{
if (m_layoutMarker) {
delete m_layoutMarker; m_layoutMarker=0;
}
}
QList<BaseDesignIntf*>& AbstractLayout::layoutsChildren()
{
return m_children;
}
bool AbstractLayout::isRelocating() const
{
return m_isRelocating;
}
void AbstractLayout::setIsRelocating(bool isRelocating)
{
m_isRelocating = isRelocating;
}
AbstractLayout::LayoutType AbstractLayout::layoutType() const
{
return m_layoutType;
}
void AbstractLayout::setLayoutType(const LayoutType& layoutType)
{
m_layoutType = layoutType;
}
void AbstractLayout::addChild(BaseDesignIntf* item, bool updateSize)
{
placeItemInLayout(item);
m_children.append(item);
item->setParentItem(this);
item->setParent(this);
item->setFixedPos(true);
item->setPossibleResizeDirectionFlags(ResizeRight | ResizeBottom);
connect(
item, SIGNAL(destroyed(QObject*)),
this, SLOT(slotOnChildDestroy(QObject*))
);
connect(
item,SIGNAL(geometryChanged(QObject*,QRectF,QRectF)),
this,SLOT(slotOnChildGeometryChanged(QObject*,QRectF,QRectF))
);
connect(
item, SIGNAL(itemVisibleHasChanged(BaseDesignIntf*)),
this, SLOT(slotOnChildVisibleHasChanged(BaseDesignIntf*))
);
connect(
item, SIGNAL(itemSelectedHasBeenChanged(BaseDesignIntf*,bool)),
this, SLOT(slotOnChildSelectionHasChanged(BaseDesignIntf*,bool))
);
if (updateSize){
relocateChildren();
updateLayoutSize();
}
}
void AbstractLayout::restoreChild(BaseDesignIntf* item)
{
if (m_children.contains(item)) return;
m_isRelocating=true;
insertItemInLayout(item);
connect(item,SIGNAL(destroyed(QObject*)),this,SLOT(slotOnChildDestroy(QObject*)));
connect(item,SIGNAL(geometryChanged(QObject*,QRectF,QRectF)),
this,SLOT(slotOnChildGeometryChanged(QObject*,QRectF,QRectF)));
connect(item, SIGNAL(itemAlignChanged(BaseDesignIntf*,ItemAlign,ItemAlign)),
this, SLOT(slotOnChildItemAlignChanged(BaseDesignIntf*,ItemAlign,ItemAlign)));
item->setFixedPos(true);
item->setPossibleResizeDirectionFlags(ResizeRight | ResizeBottom);
item->setParent(this);
item->setParentItem(this);
updateLayoutSize();
m_isRelocating=false;
}
bool AbstractLayout::isEmpty() const
{
bool isEmpty = true;
bool allItemsIsText = true;
foreach (QGraphicsItem* qgItem, childItems()) {
ContentItemDesignIntf* item = dynamic_cast<ContentItemDesignIntf*>(qgItem);
if (item && !item->content().isEmpty()) isEmpty = false;
if (!item && dynamic_cast<BaseDesignIntf*>(qgItem))
allItemsIsText = false;
}
return (isEmpty && allItemsIsText);
}
2019-01-15 13:59:00 +03:00
void AbstractLayout::paintChild(BaseDesignIntf *child, QPointF parentPos, QPainter *painter)
{
if (!child->childBaseItems().isEmpty()){
foreach (BaseDesignIntf* item, child->childBaseItems()) {
paintChild(item, child->pos(),painter);
}
}
painter->drawRect(
QRectF(parentPos.x()+child->pos().x(), parentPos.y()+child->pos().y(),
child->rect().bottomRight().rx(),
child->rect().bottomRight().ry()
)
);
}
void AbstractLayout::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
2018-06-21 14:29:00 +03:00
{
if (isSelected()){
2019-01-15 13:59:00 +03:00
painter->save();
painter->setPen(Qt::red);
2018-06-21 14:29:00 +03:00
foreach( BaseDesignIntf* item, m_children){
2019-01-15 13:59:00 +03:00
paintChild(item, QPointF(0,0), painter);
2018-06-21 14:29:00 +03:00
}
2019-01-15 13:59:00 +03:00
painter->restore();
2018-06-21 14:29:00 +03:00
}
2019-01-15 13:59:00 +03:00
LayoutDesignIntf::paint(painter, option, widget);
2018-06-21 14:29:00 +03:00
}
int AbstractLayout::childrenCount()
{
return m_children.size();
}
void AbstractLayout::beforeDelete()
{
#ifdef HAVE_QT5
foreach (QObject *item, children()) {
#else
foreach (QObject *item, QObject::children()) {
#endif
BaseDesignIntf *bi = dynamic_cast<BaseDesignIntf*>(item);
if (bi) {
bi->setParentItem(parentItem());
bi->setParent(parent());
bi->setVisible(true);
bi->setPos(mapToParent(bi->pos()));
bi->setFixedPos(false);
bi->setPossibleResizeDirectionFlags(AllDirections);
}
}
m_children.clear();
}
void AbstractLayout::childAddedEvent(BaseDesignIntf* child)
{
addChild(child,false);
}
void AbstractLayout::geometryChangedEvent(QRectF newRect, QRectF)
{
layoutMarker()->setHeight(newRect.height());
relocateChildren();
if (!isRelocating()){
divideSpace();
}
}
void AbstractLayout::initMode(BaseDesignIntf::ItemMode mode)
{
BaseDesignIntf::initMode(mode);
if ((mode==PreviewMode)||(mode==PrintMode)){
layoutMarker()->setVisible(false);
} else {
layoutMarker()->setVisible(true);
}
}
void AbstractLayout::setBorderLinesFlags(BaseDesignIntf::BorderLines flags)
{
BaseDesignIntf::setBorderLinesFlags(flags);
if (flags!=0)
relocateChildren();
}
void AbstractLayout::collectionLoadFinished(const QString& collectionName)
{
ItemDesignIntf::collectionLoadFinished(collectionName);
if (collectionName.compare("children",Qt::CaseInsensitive)==0){
#ifdef HAVE_QT5
foreach(QObject* obj, children()){
#else
foreach(QObject* obj,QObject::children()){
#endif
BaseDesignIntf* item = dynamic_cast<BaseDesignIntf*>(obj);
if (item) {
addChild(item,false);
}
}
}
}
void AbstractLayout::objectLoadFinished()
{
layoutMarker()->setHeight(height());
LayoutDesignIntf::objectLoadFinished();
}
bool AbstractLayout::isNeedUpdateSize(RenderPass pass) const
{
foreach (QGraphicsItem *child, childItems()) {
BaseDesignIntf* item = dynamic_cast<BaseDesignIntf*>(child);
if (item && (item->isNeedUpdateSize(pass) || item->isEmpty()))
return true;
}
return false;
}
QVariant AbstractLayout::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant& value)
{
if (change == QGraphicsItem::ItemSelectedHasChanged){
setIsRelocating(true);
foreach(BaseDesignIntf* item, layoutsChildren()){
item->setVisible(!value.toBool());
}
setIsRelocating(false);
}
return LayoutDesignIntf::itemChange(change, value);
}
void AbstractLayout::updateItemSize(DataSourceManager* dataManager, RenderPass pass, int maxHeight)
{
setIsRelocating(true);
ItemDesignIntf::updateItemSize(dataManager, pass, maxHeight);
foreach(QGraphicsItem *child, childItems()){
BaseDesignIntf* item = dynamic_cast<BaseDesignIntf*>(child);
if (item) item->updateItemSize(dataManager, pass, maxHeight);
}
updateLayoutSize();
relocateChildren();
setIsRelocating(false);
BaseDesignIntf::updateItemSize(dataManager, pass, maxHeight);
}
2019-02-02 00:28:30 +03:00
void AbstractLayout::rebuildChildrenIfNeeded(){
if (layoutsChildren().count() < childItems().size()-1){
layoutsChildren().clear();
foreach (BaseDesignIntf* childItem, childBaseItems()) {
layoutsChildren().append(childItem);
}
sortChildren();
}
}
BaseDesignIntf *AbstractLayout::findNext(BaseDesignIntf *item)
{
rebuildChildrenIfNeeded();
for (int i=0; i<layoutsChildren().count();++i){
if (layoutsChildren()[i]==item && layoutsChildren().size()>i+1){ return layoutsChildren()[i+1];}
}
return 0;
}
BaseDesignIntf *AbstractLayout::findPrior(BaseDesignIntf *item)
{
rebuildChildrenIfNeeded();
for (int i=0; i<layoutsChildren().count();++i){
if (layoutsChildren()[i]==item && i!=0){ return layoutsChildren()[i-1];}
}
return 0;
}
2018-06-21 14:29:00 +03:00
void AbstractLayout::slotOnChildDestroy(QObject* child)
{
m_children.removeAll(static_cast<BaseDesignIntf*>(child));
if (m_children.count()<2){
beforeDelete();
} else {
relocateChildren();
updateLayoutSize();
}
}
void AbstractLayout::slotOnChildGeometryChanged(QObject* item, QRectF newGeometry, QRectF oldGeometry)
{
if (!m_isRelocating){
if (m_layoutType == Layout){
relocateChildren();
updateLayoutSize();
} else {
m_isRelocating = true;
qreal delta = newGeometry.width()-oldGeometry.width();
BaseDesignIntf* resizingItem = findNext(dynamic_cast<BaseDesignIntf*>(item));
if (resizingItem) {
resizingItem->setWidth(resizingItem->width()-delta);
resizingItem->setPos(resizingItem->pos().x()+delta,resizingItem->pos().y());
}
updateLayoutSize();
m_isRelocating = false;
}
}
}
void AbstractLayout::slotOnChildItemAlignChanged(BaseDesignIntf* item, const BaseDesignIntf::ItemAlign&, const BaseDesignIntf::ItemAlign&)
{
item->setPossibleResizeDirectionFlags(ResizeBottom | ResizeRight);
}
void AbstractLayout::slotOnChildVisibleHasChanged(BaseDesignIntf*)
{
relocateChildren();
if (m_layoutType == Table && !m_isRelocating){
divideSpace();
}
}
void AbstractLayout::slotOnChildSelectionHasChanged(BaseDesignIntf* item, bool value)
{
item->setZValue(value ? item->zValue()+1 : item->zValue()-1);
}
int AbstractLayout::layoutSpacing() const
{
return m_layoutSpacing;
}
void AbstractLayout::setLayoutSpacing(int layoutSpacing)
{
if (m_layoutSpacing != layoutSpacing){
int oldValue = m_layoutSpacing;
m_layoutSpacing = layoutSpacing;
int delta = (m_layoutSpacing - oldValue) * (m_children.count()-1);
notify("layoutSpacing", oldValue, m_layoutSpacing);
setWidth(width() + delta);
}
}
2018-06-21 14:29:00 +03:00
bool AbstractLayout::hideEmptyItems() const
{
return m_hideEmptyItems;
}
void AbstractLayout::setHideEmptyItems(bool hideEmptyItems)
{
m_hideEmptyItems = hideEmptyItems;
if (m_hideEmptyItems != hideEmptyItems){
m_hideEmptyItems = hideEmptyItems;
notify("hideEmptyItems", !m_hideEmptyItems, m_hideEmptyItems);
}
}
2019-02-04 19:40:29 +03:00
QObject* AbstractLayout::at(int index)
2019-02-02 00:28:30 +03:00
{
rebuildChildrenIfNeeded();
if (layoutsChildren().size() > index) return layoutsChildren()[index];
return 0;
}
2018-06-21 14:29:00 +03:00
LayoutMarker* AbstractLayout::layoutMarker() const
{
return m_layoutMarker;
}
} // namespace LimeReport