backend/CBacking.cpp - devOpt - ArtemNech/simpleOpenGL

backend/CBacking.cpp
281 строка7 KB
Artem Nechitaylenko
Старый телевизор добавлен
21 май 2026, 08:11
21 май 2026, 08:11e78c117
//
// Created by artem on 1/2/25.
//

#include "CBacking.h"
#include <QImage>
#include "diagram/CInteractionController.h"
#include "diagram/CDiagram.h"

CBacking::CBacking()
{
    m_diagram = new elem::CDiagram();
}

CBacking::~CBacking()
{
    delete m_diagram;
}

/*
void CBacking::setDiagram(elem::IDiagram *diagram)
{
    m_diagram = diagram;
    m_controller->setDiagram(diagram);
    updateVisibleData();
    if (m_diagram)
        m_diagram->activateInBacking();
}*/

elem::IDiagram *CBacking::diagram() const
{
    return m_diagram;
}

const std::vector<const elem::IDiagramObject *> &CBacking::getVisibleObjects()
{
    m_visibleObjects.clear();

    for (auto & item : m_diagram->objects())
    {
        for (auto & items : item->imageElements())
        {
            if(m_viewportRect.contains(items.rect))
                m_visibleObjects.push_back(item);
        }
    }

    return  m_visibleObjects;
}

const std::vector<elem::STextElement > &CBacking::getVisibleTextElements() const
{
    return m_visibleTextElements;
}

void CBacking::setViewportRect(const ngraph::NRectF &viewport)
{
    m_viewportRect = viewport;
    if (m_sizeCallback)
        m_sizeCallback(m_viewportRect.size());
    if (m_cameraCallback)
        m_cameraCallback(m_viewportRect.left_top());

    updateVisibleData();
}

void CBacking::setViewTransform(const ngraph::NTransform &transform)
{
    m_viewTransform = transform;
}

const ngraph::NTransform & CBacking::getViewTransform()
{
    if (m_diagram)
    {
        return m_diagram->viewTransform();
    }
    return m_viewTransform;
}

void CBacking::setGridEnabled(bool enabled)
{
    m_gridEnabled = enabled;
}

bool CBacking::isGridEnabled() const
{
    return m_gridEnabled;
}

const std::vector<std::pair<ngraph::NRectF, ngraph::NColor>> &CBacking::getHighlightData() const
{
    return m_highlightData;
}

void CBacking::setHighlightData(const std::vector<std::pair<ngraph::NRectF, ngraph::NColor>> &highlightData)
{
    m_highlightData = highlightData;
}

void CBacking::updateVisibleData()
{
    m_visibleObjects.clear();
    m_visibleTextElements.clear();

    if (!m_diagram)
    {
        return;
    };

    auto objects = m_diagram->objects();
    auto texts = m_diagram->textElements();

    for (auto obj : objects) {
        if (isObjectVisible(obj)) {
            m_visibleObjects.push_back(obj);
        }
    }

    for (auto &text : texts) {
        if (isTextVisible(text)) {
            m_visibleTextElements.push_back(text);
        }
    }

    // update lines of the main caps

}

bool CBacking::isObjectVisible(const elem::IDiagramObject *obj) const
{
    ngraph::NRectF objRect = obj->boundingRect();
    ngraph::NRectF transformedRect = m_viewTransform.map(objRect);

    return m_viewportRect.intersects(transformedRect);
}

bool CBacking::isTextVisible(const elem::STextElement &text) const
{
    ngraph::NRectF textRect = text.boundingRect;
    ngraph::NRectF transformedRect = m_viewTransform.map(textRect);
    return m_viewportRect.intersects(transformedRect);
}

ngraph::NRectF CBacking::getViewportRect() const
{
    return m_viewportRect;
}

void CBacking::updateViewTransform() {
    // Трансформация = панорамирование + масштабирование
    ngraph::NTransform pan = ngraph::NTransform::translate(m_panOffset.x(), m_panOffset.y());
    ngraph::NTransform zoom = ngraph::NTransform::scale(m_zoom, m_zoom);
    m_viewTransform = pan.combined(zoom);

}

void CBacking::zoomToRect(const ngraph::NRectF& rect) {
    // Вычисляем zoom чтобы rect влез в viewport
    double scaleX = m_viewportRect.width() / rect.width();
    double scaleY = m_viewportRect.height() / rect.height();
    m_zoom = std::min(scaleX, scaleY) * 0.9; // 10% отступ

    // Центрируем
    m_panOffset = ngraph::NPointF(
        -rect.left() * m_zoom + (m_viewportRect.width() - rect.width() * m_zoom) / 2,
        -rect.top() * m_zoom + (m_viewportRect.height() - rect.height() * m_zoom) / 2
        );

    updateViewTransform();
    updateVisibleData();
}

void CBacking::fitToView() {
    if (m_diagram) {
        zoomToRect(m_diagram->documentBounds());
    }
}

void CBacking::setHorizontalScroll(int position, int maxValue) {
    if (maxValue <= 0) return;

    // position от 0 до maxValue → смещение от 0 до (docWidth - viewportWidth)
    ngraph::NRectF docBounds = m_diagram ? m_diagram->documentBounds() : ngraph::NRectF(0, 0, 1000, 1000);
    auto dw = docBounds.width();
    auto vw = m_viewportRect.width() / m_zoom;

    double maxOffsetX = std::max(0.0, vw - dw);

    // Преобразуем позицию скроллбара в смещение
    double ratio = static_cast<double>(position) / maxValue;
    m_panOffset.set_x(-maxOffsetX * ratio);

    updateViewTransform();
    updateVisibleData();
}

void CBacking::setVerticalScroll(int position, int maxValue) {
    if (maxValue <= 0) return;

    ngraph::NRectF docBounds = m_diagram ? m_diagram->documentBounds() : ngraph::NRectF(0, 0, 1000, 1000);
    double maxOffsetY = std::max(0.0, m_viewportRect.height() / m_zoom - docBounds.height());

    double ratio = static_cast<double>(position) / maxValue;
    m_panOffset.set_y(-maxOffsetY * ratio);

    updateViewTransform();
    updateVisibleData();
}

int CBacking::horizontalScrollPosition() const {
    ngraph::NRectF docBounds = m_diagram ? m_diagram->documentBounds() : ngraph::NRectF(0, 0, 1000, 1000);
    double maxOffsetX = std::max(0.0, docBounds.width() - m_viewportRect.width() / m_zoom);

    if (maxOffsetX <= 0) return 0;

    double ratio = -m_panOffset.x() / maxOffsetX;
    return static_cast<int>(ratio * horizontalScrollMaximum());
}

int CBacking::verticalScrollPosition() const {
    ngraph::NRectF docBounds = m_diagram ? m_diagram->documentBounds() : ngraph::NRectF(0, 0, 1000, 1000);
    double maxOffsetY = std::max(0.0, docBounds.height() - m_viewportRect.height() / m_zoom);

    if (maxOffsetY <= 0) return 0;

    double ratio = -m_panOffset.y() / maxOffsetY;
    return static_cast<int>(ratio * verticalScrollMaximum());
}

int CBacking::horizontalScrollMaximum() const {
    return 1000; // Фиксированный максимум для плавности
}

int CBacking::verticalScrollMaximum() const {
    return 1000;
}

void CBacking::updateScrollRanges() {
    // Можно вызвать при изменении диаграммы или масштаба
    // чтобы обновить скроллбары в UI
}

void CBacking::setPanOffset(const ngraph::NPointF &offset)
{
    m_panOffset = offset;

    if (m_cameraCallback)
        m_cameraCallback(offset);

    updateViewTransform();
    updateVisibleData();
    updateScrollRanges();

}

const NDrag *CBacking::draggingObjects()
{
    if (m_diagram)
    {
        return m_diagram->dragObjects();
    }
    return nullptr;
}

void CBacking::setInteractionController(CInteractionController *controller)
{
    m_controller = controller;
    m_controller->setDiagram(m_diagram);
    m_diagram->setInteractionController(controller);
}

const std::vector<elem::IConnectingLine*> CBacking::getVisibleConnections()
{
    if (m_diagram)
    {
        return m_diagram->visibleLines();
    }
    return {};
}
// const std::vector<elem::IConnectingLine> visibleLines();