DataProperties.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Data/DataProperties.cpp
//! @brief     Implements class DataPresentationProperties and its descendants
//!
//! @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/Model/Data/DataProperties.h"
#include "GUI/Model/Data/DataItem.h"
#include "GUI/Model/Device/InstrumentItems.h"
#include "GUI/Model/Job/JobItem.h"
#include "GUI/Model/Model/SessionModel.h"
#include "GUI/Util/ComboProperty.h"
#include "GUI/Util/Error.h"
#include "GUI/Util/Path.h"
#include <QColor>
#include <utility>
 
namespace {
 
// set of simple colors for representation of 1D graphs
const std::vector<std::pair<QString, Qt::GlobalColor>> color_queue = {
    {"Black", Qt::GlobalColor::black},   {"Blue", Qt::GlobalColor::blue},
    {"Red", Qt::GlobalColor::darkRed},   {"Cyan", Qt::GlobalColor::darkCyan},
    {"Gray", Qt::GlobalColor::darkGray}, {"Magenta", Qt::GlobalColor::darkMagenta}};
 
// scatters for representation of 1D graphs
const QMap<QString, QCPScatterStyle::ScatterShape> scatter_map = {
    {"None", QCPScatterStyle::ScatterShape::ssNone},
    {"Disc", QCPScatterStyle::ScatterShape::ssDisc},
    {"Circle", QCPScatterStyle::ScatterShape::ssCircle},
    {"Cross", QCPScatterStyle::ScatterShape::ssCross},
    {"Diamond", QCPScatterStyle::ScatterShape::ssDiamond},
    {"Star", QCPScatterStyle::ScatterShape::ssStar}};
 
// connection lines for representation of 1D graphs
const QMap<QString, QCPGraph::LineStyle> line_map = {
    {"None", QCPGraph::LineStyle::lsNone},
    {"Line", QCPGraph::LineStyle::lsLine},
    {"StepLeft", QCPGraph::LineStyle::lsStepLeft},
    {"StepRight", QCPGraph::LineStyle::lsStepRight},
    {"StepCenter", QCPGraph::LineStyle::lsStepCenter},
    {"Impulse", QCPGraph::LineStyle::lsImpulse}};
 
struct ColorNameComparator {
    ColorNameComparator(QString value_to_comp)
        : m_value_to_comp(std::move(value_to_comp))
    {
    }
    bool operator()(const std::pair<QString, Qt::GlobalColor>& value) const
    {
        return value.first == m_value_to_comp;
    }
 
    const QString m_value_to_comp;
};
 
ComboProperty defaultColorCombo()
{
    ComboProperty result;
    for (const auto& color : color_queue)
        result << color.first;
    result.setValue(color_queue.front().first);
    return result;
}
 
ComboProperty defaultScatterCombo()
{
    ComboProperty result;
    for (const auto& scatter : scatter_map.keys())
        result << scatter;
    result.setValue(scatter_map.keys().first());
    return result;
}
 
ComboProperty defaultLineCombo()
{
    ComboProperty result;
    for (const auto& line : line_map.keys())
        result << line;
    result.setValue(line_map.keys().first());
    return result;
}
 
// TODO cover with unit tests and simplify
 
QModelIndex getIndexFromPath(const SessionModel* model, const QString& path)
{
    if (!model)
        return {};
 
    QStringList parts = path.split("/");
    SessionItem* t = model->rootItem();
    for (int i = 0; i < parts.length(); i++) {
        for (int j = 0; j < t->numberOfChildren(); j++) {
            if (t->childAt(j)->itemName() == parts[i]) {
                t = t->childAt(j);
                break;
            }
        }
    }
    return t->index();
}
 
} // namespace
 
 
DataProperties::DataProperties(const QString& model_type)
    : SessionItem(model_type)
{
    addProperty(P_DATALINK, QString());
}
 
void DataProperties::setDataItem(DataItem* item)
{
    const QString& path = GUI::Util::Path::getPathFromIndex(item->index());
    setItemValue(P_DATALINK, path);
}
 
DataItem* DataProperties::dataItem()
{
    SessionModel* hosting_model = this->model();
    const QString& path = getItemValue(P_DATALINK).toString();
    auto item_index = getIndexFromPath(hosting_model, path);
    ASSERT(item_index.isValid());
    auto* item = hosting_model->itemForIndex(item_index);
    return dynamic_cast<DataItem*>(item);
}
 
Data1DProperties::Data1DProperties()
    : DataProperties(M_TYPE)
{
    addProperty(P_COLOR, defaultColorCombo().variant());
    addProperty(P_SCATTER, defaultScatterCombo().variant());
    addProperty(P_LINE, defaultLineCombo().variant());
}
 
QColor Data1DProperties::color()
{
    const QString& color_name = getItemValue(P_COLOR).value<ComboProperty>().getValue();
    auto iter =
        std::find_if(color_queue.begin(), color_queue.end(), ColorNameComparator(color_name));
    ASSERT(iter != color_queue.end());
    return QColor(iter->second);
}
 
QString Data1DProperties::colorName() const
{
    return getItemValue(P_COLOR).value<ComboProperty>().getValue();
}
 
const QString& Data1DProperties::nextColorName(Data1DProperties* properties)
{
    if (!properties)
        return color_queue.front().first;
    const auto& current_color = properties->getItemValue(P_COLOR).value<ComboProperty>().getValue();
    auto iter =
        std::find_if(color_queue.begin(), color_queue.end(), ColorNameComparator(current_color));
    if (iter == color_queue.end() || *iter == color_queue.back())
        return color_queue.front().first;
    return (++iter)->first;
}
 
void Data1DProperties::setColorProperty(const QString& color_name)
{
    auto color_combo = defaultColorCombo();
    color_combo.setValue(color_name);
    setItemValue(P_COLOR, color_combo.variant());
}
 
QCPScatterStyle::ScatterShape Data1DProperties::scatter()
{
    const QString& scatter_name = getItemValue(P_SCATTER).value<ComboProperty>().getValue();
    bool contains = scatter_map.contains(scatter_name);
    ASSERT(contains);
    return QCPScatterStyle::ScatterShape(scatter_map.value(scatter_name));
}
 
QCPGraph::LineStyle Data1DProperties::line()
{
    const QString& line_name = getItemValue(P_LINE).value<ComboProperty>().getValue();
    bool contains = line_map.contains(line_name);
    ASSERT(contains);
    return QCPGraph::LineStyle(line_map.value(line_name));
}
 
void Data1DProperties::setScatterProperty(const QString& scatter_name)
{
    auto scatter_combo = defaultScatterCombo();
    scatter_combo.setValue(scatter_name);
    setItemValue(P_SCATTER, scatter_combo.variant());
}
 
void Data1DProperties::setLineProperty(const QString& line_name)
{
    auto line_combo = defaultLineCombo();
    line_combo.setValue(line_name);
    setItemValue(P_LINE, line_combo.variant());
}