ProjectionsEditorCanvas.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/Projection/ProjectionsEditorCanvas.cpp
//! @brief     Implements class ProjectionsEditorCanvas
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/View/Projection/ProjectionsEditorCanvas.h"
#include "GUI/Model/Data/IntensityDataItem.h"
#include "GUI/Model/Device/MaskItems.h"
#include "GUI/Model/Model/SessionModel.h"
#include "GUI/View/Mask/MaskGraphicsScene.h"
#include "GUI/View/Mask/MaskGraphicsView.h"
#include "GUI/View/PlotUtil/ColorMap.h"
#include "GUI/View/PlotUtil/PlotStatusLabel.h"
#include "GUI/View/PlotUtil/ScientificPlotEvent.h"
#include <QItemSelectionModel>
#include <QVBoxLayout>
 
#include <boost/polymorphic_cast.hpp>
 
using boost::polymorphic_downcast;
 
ProjectionsEditorCanvas::ProjectionsEditorCanvas(QWidget* parent)
    : QWidget(parent)
    , m_scene(new MaskGraphicsScene(this))
    , m_view(new MaskGraphicsView(m_scene))
    , m_colorMap(nullptr)
    , m_statusLabel(new PlotStatusLabel(nullptr, this))
    , m_liveProjection(nullptr)
    , m_model(nullptr)
    , m_intensityDataItem(nullptr)
    , m_currentActivity(MaskEditorFlags::HORIZONTAL_LINE_MODE)
    , m_block_update(false)
{
    setObjectName("MaskEditorCanvas");
    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
    auto* mainLayout = new QVBoxLayout;
    mainLayout->addWidget(m_view);
    mainLayout->addWidget(m_statusLabel);
    mainLayout->setMargin(0);
    mainLayout->setSpacing(0);
    setLayout(mainLayout);
 
    connect(m_view, &MaskGraphicsView::changeActivityRequest, this,
            &ProjectionsEditorCanvas::changeActivityRequest);
    connect(m_view, &MaskGraphicsView::deleteSelectedRequest, this,
            &ProjectionsEditorCanvas::deleteSelectedRequest);
}
 
void ProjectionsEditorCanvas::setContext(SessionModel* model,
                                         const QModelIndex& shapeContainerIndex,
                                         IntensityDataItem* intensityItem)
{
    m_model = model;
    m_scene->setMaskContext(model, shapeContainerIndex, intensityItem);
    m_view->updateSize(m_view->size());
 
    m_containerIndex = shapeContainerIndex;
    m_intensityDataItem = intensityItem;
 
    setColorMap(m_scene->colorMap());
 
    getScene()->onActivityModeChanged(m_currentActivity);
}
 
void ProjectionsEditorCanvas::resetContext()
{
    m_intensityDataItem = nullptr;
    m_containerIndex = {};
    setConnected(false);
    m_colorMap = nullptr;
    m_scene->resetContext();
}
 
void ProjectionsEditorCanvas::setSelectionModel(QItemSelectionModel* model)
{
    getScene()->setSelectionModel(model);
}
 
void ProjectionsEditorCanvas::onEnteringColorMap()
{
    if (m_liveProjection || m_block_update)
        return;
 
    m_block_update = true;
 
    if (m_currentActivity == MaskEditorFlags::HORIZONTAL_LINE_MODE)
        m_liveProjection = m_model->insertItem<HorizontalLineItem>(m_containerIndex);
    else if (m_currentActivity == MaskEditorFlags::VERTICAL_LINE_MODE)
        m_liveProjection = m_model->insertItem<VerticalLineItem>(m_containerIndex);
 
    if (m_liveProjection)
        m_liveProjection->setIsVisibleValue(false);
 
    m_block_update = false;
}
 
void ProjectionsEditorCanvas::onLeavingColorMap()
{
    if (m_block_update)
        return;
 
    m_block_update = true;
 
    if (m_liveProjection) {
        m_liveProjection->parentItem()->takeRow(
            m_liveProjection->parentItem()->rowOfChild(m_liveProjection));
        delete m_liveProjection;
        m_liveProjection = nullptr;
    }
 
    m_block_update = false;
}
 
void ProjectionsEditorCanvas::onPositionChanged(double x, double y)
{
    if (m_block_update)
        return;
 
    m_block_update = true;
 
    if (m_liveProjection) {
        if (m_currentActivity == MaskEditorFlags::HORIZONTAL_LINE_MODE)
            polymorphic_downcast<HorizontalLineItem*>(m_liveProjection)->setPosY(y);
        else if (m_currentActivity == MaskEditorFlags::VERTICAL_LINE_MODE)
            polymorphic_downcast<VerticalLineItem*>(m_liveProjection)->setPosX(x);
    }
 
    m_block_update = false;
}
 
void ProjectionsEditorCanvas::onResetViewRequest()
{
    m_view->onResetViewRequest();
    m_intensityDataItem->resetView();
}
 
void ProjectionsEditorCanvas::onActivityModeChanged(MaskEditorFlags::Activity value)
{
    m_currentActivity = value;
    getScene()->onActivityModeChanged(value);
    onLeavingColorMap();
}
 
void ProjectionsEditorCanvas::setColorMap(ColorMap* colorMap)
{
    ASSERT(colorMap);
    setConnected(false);
 
    m_colorMap = colorMap;
    setConnected(true);
 
    m_statusLabel->reset();
    m_statusLabel->addPlot(colorMap);
}
 
void ProjectionsEditorCanvas::setConnected(bool isConnected)
{
    if (!m_colorMap)
        return;
 
    if (isConnected) {
        connect(m_colorMap->plotEvent(), &ScientificPlotEvent::enteringPlot, this,
                &ProjectionsEditorCanvas::onEnteringColorMap, Qt::UniqueConnection);
        connect(m_colorMap->plotEvent(), &ScientificPlotEvent::leavingPlot, this,
                &ProjectionsEditorCanvas::onLeavingColorMap, Qt::UniqueConnection);
        connect(m_colorMap->plotEvent(), &ScientificPlotEvent::positionChanged, this,
                &ProjectionsEditorCanvas::onPositionChanged, Qt::UniqueConnection);
        connect(m_colorMap, &ColorMap::marginsChanged, this,
                &ProjectionsEditorCanvas::marginsChanged, Qt::UniqueConnection);
    }
 
    else {
        disconnect(m_colorMap->plotEvent(), &ScientificPlotEvent::enteringPlot, this,
                   &ProjectionsEditorCanvas::onEnteringColorMap);
        disconnect(m_colorMap->plotEvent(), &ScientificPlotEvent::leavingPlot, this,
                   &ProjectionsEditorCanvas::onLeavingColorMap);
        disconnect(m_colorMap->plotEvent(), &ScientificPlotEvent::positionChanged, this,
                   &ProjectionsEditorCanvas::onPositionChanged);
        disconnect(m_colorMap, &ColorMap::marginsChanged, this,
                   &ProjectionsEditorCanvas::marginsChanged);
    }
}