LimeReport/limereport/lritemscontainerdesignitf.cpp

#include "lritemscontainerdesignitf.h"

#include "lrbanddesignintf.h"
#include "lritemdesignintf.h"

namespace LimeReport {

bool Segment::intersect(Segment value)
{
    return (value.m_begin <= m_end) && (value.m_end >= m_begin);
}

qreal Segment::intersectValue(Segment value)
{
    if (!intersect(value))
        return 0;
    if ((value.m_end >= m_begin) && (value.m_end <= m_end)) {
        return value.m_end - m_begin;
    }
    if ((value.m_begin >= m_begin) && (value.m_end >= m_end)) {
        return m_end - value.m_begin;
    }
    if ((value.m_begin >= m_begin) && (value.m_end <= m_end)) {
        return value.m_end - value.m_begin;
    }
    if ((value.m_begin < m_begin) && (value.m_end > m_end)) {
        return m_end - m_begin;
    }
    return 0;
}

bool itemSortContainerLessThen(const PItemSortContainer c1, const PItemSortContainer c2)
{
    VSegment vS1(c1->m_rect), vS2(c2->m_rect);
    HSegment hS1(c1->m_rect), hS2(c2->m_rect);
    if (vS1.intersectValue(vS2) > hS1.intersectValue(hS2))
        return c1->m_rect.x() < c2->m_rect.x();
    else
        return c1->m_rect.y() < c2->m_rect.y();
}

void ItemsContainerDesignInft::snapshotItemsLayout(SnapshotType type)
{
    m_containerItems.clear();
    foreach (BaseDesignIntf* childItem, childBaseItems()) {
        if (type == IgnoreBands) {
            if (!dynamic_cast<BandDesignIntf*>(childItem))
                m_containerItems.append(PItemSortContainer(new ItemSortContainer(childItem)));
        } else
            m_containerItems.append(PItemSortContainer(new ItemSortContainer(childItem)));
    }
    std::sort(m_containerItems.begin(), m_containerItems.end(), itemSortContainerLessThen);
}

void ItemsContainerDesignInft::arrangeSubItems(RenderPass pass, DataSourceManager* dataManager,
                                               ArrangeType type)
{
    bool needArrage = (type == Force);

    foreach (PItemSortContainer item, m_containerItems) {
        if (item->m_item->isNeedUpdateSize(pass)) {
            item->m_item->updateItemSize(dataManager, pass);
            needArrage = true;
        }
    }

    if (needArrage) {
        for (int i = 0; i < m_containerItems.count(); i++) {
            for (int j = i; j < m_containerItems.count(); j++) {
                if ((i != j)
                    && (m_containerItems[i]->m_item->collidesWithItem(
                        m_containerItems[j]->m_item))) {
                    HSegment hS1(m_containerItems[j]->m_rect), hS2(m_containerItems[i]->m_rect);
                    VSegment vS1(m_containerItems[j]->m_rect), vS2(m_containerItems[i]->m_rect);
                    if (m_containerItems[i]->m_rect.bottom()
                        < m_containerItems[i]->m_item->geometry().bottom()) {
                        if (hS1.intersectValue(hS2) > vS1.intersectValue(vS2))
                            m_containerItems[j]->m_item->setY(
                                m_containerItems[i]->m_item->y()
                                + m_containerItems[i]->m_item->height()
                                + m_containerItems[j]->m_rect.top()
                                - m_containerItems[i]->m_rect.bottom());
                    }
                    if (m_containerItems[i]->m_rect.right()
                        < m_containerItems[i]->m_item->geometry().right()) {
                        if (vS1.intersectValue(vS2) > hS1.intersectValue(hS2))
                            m_containerItems[j]->m_item->setX(
                                m_containerItems[i]->m_item->geometry().right()
                                + (m_containerItems[j]->m_rect.x()
                                   - m_containerItems[i]->m_rect.right()));
                    }
                }
            }
        }
    }

    if (needArrage || pass == FirstPass) {
        int maxBottom = findMaxBottom();
        foreach (BaseDesignIntf* item, childBaseItems()) {
            ItemDesignIntf* childItem = dynamic_cast<ItemDesignIntf*>(item);
            if (childItem) {
                if (childItem->stretchToMaxHeight())
                    childItem->setHeight(maxBottom - childItem->geometry().top());
            }
        }
    }
}

qreal ItemsContainerDesignInft::findMaxBottom() const
{
    qreal maxBottom = 0;
    foreach (QGraphicsItem* item, childItems()) {
        BaseDesignIntf* subItem = dynamic_cast<BaseDesignIntf*>(item);
        if (subItem)
            if (subItem->isVisible() && (subItem->geometry().bottom() > maxBottom))
                maxBottom = subItem->geometry().bottom();
    }
    return maxBottom;
}

qreal ItemsContainerDesignInft::findMinTop() const
{
    qreal minTop = height();
    foreach (QGraphicsItem* item, childItems()) {
        BaseDesignIntf* subItem = dynamic_cast<BaseDesignIntf*>(item);
        if (subItem)
            if (subItem->isVisible() && (subItem->geometry().top() < minTop))
                minTop = subItem->geometry().top();
    }
    return minTop > 0 ? minTop : 0;
}

qreal ItemsContainerDesignInft::findMaxHeight() const
{
    qreal maxHeight = 0;
    foreach (QGraphicsItem* item, childItems()) {
        BaseDesignIntf* subItem = dynamic_cast<BaseDesignIntf*>(item);
        if (subItem)
            if (subItem->geometry().height() > maxHeight)
                maxHeight = subItem->geometry().height();
    }
    return maxHeight;
}

} // namespace LimeReport