diff --git a/GUI/coregui/Models/ApplicationModels.cpp b/GUI/coregui/Models/ApplicationModels.cpp
index 08e7be06765318865aa8d0e845384723cb8a05a8..4f41e5d5759de5ff1f76d75ce992a4f5a4f9c9f0 100644
--- a/GUI/coregui/Models/ApplicationModels.cpp
+++ b/GUI/coregui/Models/ApplicationModels.cpp
@@ -81,7 +81,7 @@ JobModel* ApplicationModels::jobModel()
void ApplicationModels::resetModels()
{
m_documentModel->clear();
- m_documentModel->insertNewItem(Constants::SimulationOptionsType);
+ m_documentModel->insertNewItem("SimulationOptions");
m_materialModel->clear();
m_materialModel->addRefractiveMaterial("Default", 1e-3, 1e-5);
@@ -96,7 +96,7 @@ void ApplicationModels::resetModels()
m_jobModel->clear();
m_instrumentModel->clear();
- SessionItem* instrument = m_instrumentModel->insertNewItem(Constants::GISASInstrumentType);
+ SessionItem* instrument = m_instrumentModel->insertNewItem("GISASInstrument");
instrument->setItemName("GISAS");
}
@@ -181,7 +181,7 @@ void ApplicationModels::createTestJob()
void ApplicationModels::createTestRealData()
{
auto realDataItem =
- dynamic_cast<RealDataItem*>(m_realDataModel->insertNewItem(Constants::RealDataType));
+ dynamic_cast<RealDataItem*>(m_realDataModel->insertNewItem("RealData"));
realDataItem->setItemName("realdata");
std::unique_ptr<OutputData<double>> data(
diff --git a/GUI/coregui/Models/AxesItems.cpp b/GUI/coregui/Models/AxesItems.cpp
index e274d1d578ba60c63c87ac8018676c8a823080db..e7484c60bb02c0ab7a88b47c881c0a56c20a9f66 100644
--- a/GUI/coregui/Models/AxesItems.cpp
+++ b/GUI/coregui/Models/AxesItems.cpp
@@ -55,20 +55,20 @@ void BasicAxisItem::register_basic_properties()
const QString AmplitudeAxisItem::P_IS_LOGSCALE = "log10";
const QString AmplitudeAxisItem::P_LOCK_MIN_MAX = "Lock (min, max)";
-AmplitudeAxisItem::AmplitudeAxisItem() : BasicAxisItem(Constants::AmplitudeAxisType)
+AmplitudeAxisItem::AmplitudeAxisItem() : BasicAxisItem("AmplitudeAxis")
{
addProperty(P_LOCK_MIN_MAX, false)->setVisible(false);
addProperty(P_IS_LOGSCALE, true);
getItem(BasicAxisItem::P_TITLE)->setVisible(false);
getItem(BasicAxisItem::P_IS_VISIBLE)->setVisible(true);
- setMinMaxEditor(Constants::ScientificEditorType);
+ setMinMaxEditor("ScientificDouble");
mapper()->setOnPropertyChange([this](const QString& name) {
if (name == P_IS_LOGSCALE) {
if (getItemValue(P_IS_LOGSCALE).toBool())
- setMinMaxEditor(Constants::ScientificEditorType);
+ setMinMaxEditor("ScientificDouble");
else
- setMinMaxEditor(Constants::DefaultEditorType);
+ setMinMaxEditor("Default");
}
});
}
diff --git a/GUI/coregui/Models/AxesItems.h b/GUI/coregui/Models/AxesItems.h
index 40a063f9fba4058414a50575499ef39d37f49125..cc2f0cec79c6fc4f328f7cd07d4ea254c36404f2 100644
--- a/GUI/coregui/Models/AxesItems.h
+++ b/GUI/coregui/Models/AxesItems.h
@@ -30,7 +30,7 @@ public:
static const QString P_TITLE;
static const QString P_TITLE_IS_VISIBLE;
- explicit BasicAxisItem(const QString& type = Constants::BasicAxisType);
+ explicit BasicAxisItem(const QString& type = "BasicAxis");
virtual ~BasicAxisItem();
virtual std::unique_ptr<IAxis> createAxis(double scale) const;
diff --git a/GUI/coregui/Models/BackgroundItems.cpp b/GUI/coregui/Models/BackgroundItems.cpp
index 7ae63b479df469ee9644a2187455cb8ecdcf69de..7059e6ecfe8317eb8b1ae7d61e264444fb098e55 100644
--- a/GUI/coregui/Models/BackgroundItems.cpp
+++ b/GUI/coregui/Models/BackgroundItems.cpp
@@ -15,14 +15,13 @@
#include "GUI/coregui/Models/BackgroundItems.h"
#include "Core/Computation/ConstantBackground.h"
#include "Core/Computation/PoissonNoiseBackground.h"
-#include "GUI/coregui/Models/item_constants.h"
BackgroundItem::BackgroundItem(const QString& model_type) : SessionItem(model_type) {}
// Background none
/* ------------------------------------------------ */
-BackgroundNoneItem::BackgroundNoneItem() : BackgroundItem(Constants::BackgroundNoneType) {}
+BackgroundNoneItem::BackgroundNoneItem() : BackgroundItem("NoBackground") {}
std::unique_ptr<IBackground> BackgroundNoneItem::createBackground() const
{
@@ -39,7 +38,7 @@ const QString constant_background_value_tooltip = "Constant background value [co
const QString ConstantBackgroundItem::P_VALUE = QString::fromStdString("BackgroundValue");
-ConstantBackgroundItem::ConstantBackgroundItem() : BackgroundItem(Constants::ConstantBackgroundType)
+ConstantBackgroundItem::ConstantBackgroundItem() : BackgroundItem("ConstantBackground")
{
addProperty(P_VALUE, 0.0)
->setLimits(RealLimits::nonnegative())
@@ -55,7 +54,7 @@ std::unique_ptr<IBackground> ConstantBackgroundItem::createBackground() const
/* ------------------------------------------------ */
PoissonNoiseBackgroundItem::PoissonNoiseBackgroundItem()
- : BackgroundItem(Constants::PoissonNoiseBackgroundType)
+ : BackgroundItem("PoissonNoiseBackground")
{
}
diff --git a/GUI/coregui/Models/BeamAngleItems.cpp b/GUI/coregui/Models/BeamAngleItems.cpp
index ae5ae96e9c7e98d482e72cf9a86737b666cf3103..2407e2c53d6ef7130f492c52bd6717d61b0f8349 100644
--- a/GUI/coregui/Models/BeamAngleItems.cpp
+++ b/GUI/coregui/Models/BeamAngleItems.cpp
@@ -16,9 +16,9 @@
#include "Core/Parametrization/Units.h"
BeamAzimuthalAngleItem::BeamAzimuthalAngleItem()
- : BeamDistributionItem(Constants::BeamAzimuthalAngleType, m_show_mean)
+ : BeamDistributionItem("BeamAzimuthalAngle", m_show_mean)
{
- register_distribution_group(Constants::DistributionExtendedGroup);
+ register_distribution_group("Distribution extended group");
SessionItem* valueItem = getGroupItem(P_DISTRIBUTION)->getItem(DistributionNoneItem::P_MEAN);
valueItem->setLimits(RealLimits::limited(-90.0, 90.0));
@@ -43,9 +43,9 @@ double BeamAzimuthalAngleItem::scaleFactor() const
// ------------------------------------------------------------------------------------------------
BeamInclinationAngleItem::BeamInclinationAngleItem()
- : BeamDistributionItem(Constants::BeamInclinationAngleType, m_show_mean)
+ : BeamDistributionItem("BeamInclinationAngle", m_show_mean)
{
- register_distribution_group(Constants::DistributionExtendedGroup);
+ register_distribution_group("Distribution extended group");
SessionItem* valueItem = getGroupItem(P_DISTRIBUTION)->getItem(DistributionNoneItem::P_MEAN);
valueItem->setLimits(RealLimits::limited(0.0, 90.0));
diff --git a/GUI/coregui/Models/BeamDistributionItem.cpp b/GUI/coregui/Models/BeamDistributionItem.cpp
index f111ce088f725f24187d6ae6d0f22c68ae68efb8..72446ecb02f4c15e72f208132f70fcef5829dec7 100644
--- a/GUI/coregui/Models/BeamDistributionItem.cpp
+++ b/GUI/coregui/Models/BeamDistributionItem.cpp
@@ -27,7 +27,7 @@ BeamDistributionItem::BeamDistributionItem(const QString& name, bool show_mean)
addTranslator(DistributionNoneTranslator());
mapper()->setOnChildPropertyChange([this, show_mean](SessionItem* item, const QString&) {
- if (item->modelType() == Constants::GroupItemType && item->parent() == this)
+ if (item->modelType() == "GroupProperty" && item->parent() == this)
initDistributionItem(show_mean);
});
}
@@ -71,7 +71,7 @@ void BeamDistributionItem::initDistributionItem(bool show_mean)
SessionItem* distributionNone = nullptr;
for (auto item : groupItem->getItems(GroupItem::T_ITEMS)) {
- if (item->modelType() == Constants::DistributionNoneType) {
+ if (item->modelType() == "DistributionNone") {
distributionNone = item;
break;
}
@@ -118,7 +118,7 @@ double BeamDistributionItem::meanValue() const
void BeamDistributionItem::resetToValue(double value)
{
SessionItem* distributionItem =
- setGroupProperty(BeamDistributionItem::P_DISTRIBUTION, Constants::DistributionNoneType);
+ setGroupProperty(BeamDistributionItem::P_DISTRIBUTION, "DistributionNone");
Q_ASSERT(distributionItem);
distributionItem->setItemValue(DistributionNoneItem::P_MEAN, value);
}
@@ -133,8 +133,8 @@ double BeamDistributionItem::scaleFactor() const
void BeamDistributionItem::register_distribution_group(const QString& group_type)
{
- Q_ASSERT(group_type == Constants::DistributionExtendedGroup
- || group_type == Constants::SymmetricDistributionGroup);
+ Q_ASSERT(group_type == "Distribution extended group"
+ || group_type == "Symmetric distribution group");
addGroupProperty(P_DISTRIBUTION, group_type);
}
diff --git a/GUI/coregui/Models/BeamItems.cpp b/GUI/coregui/Models/BeamItems.cpp
index b3569cc3ea4422a4ae0cc395ef1c7840b4d6dcc8..f38cb62456292f57b0f304e0eeafea72ceb994f9 100644
--- a/GUI/coregui/Models/BeamItems.cpp
+++ b/GUI/coregui/Models/BeamItems.cpp
@@ -50,10 +50,10 @@ BeamItem::BeamItem(const QString& beam_model) : SessionItem(beam_model)
addProperty(P_INTENSITY, 1e+08)
->setLimits(RealLimits::limited(0.0, 1e+32))
.setToolTip("Beam intensity in neutrons (or gammas) per sec.")
- .setEditorType(Constants::ScientificEditorType);
+ .setEditorType("ScientificDouble");
- addGroupProperty(P_AZIMUTHAL_ANGLE, Constants::BeamAzimuthalAngleType);
- addGroupProperty(P_POLARIZATION, Constants::VectorType)->setToolTip(polarization_tooltip);
+ addGroupProperty(P_AZIMUTHAL_ANGLE, "BeamAzimuthalAngle");
+ addGroupProperty(P_POLARIZATION, "Vector")->setToolTip(polarization_tooltip);
addTranslator(VectorParameterTranslator(P_POLARIZATION, "BlochVector"));
}
@@ -136,15 +136,15 @@ const QString SpecularBeamItem::P_FOOPTPRINT = QString("Footprint");
const QString footprint_group_label("Type");
-SpecularBeamItem::SpecularBeamItem() : BeamItem(Constants::SpecularBeamType)
+SpecularBeamItem::SpecularBeamItem() : BeamItem("SpecularBeam")
{
- setInclinationProperty(Constants::SpecularBeamInclinationType);
- setWavelengthProperty(Constants::SpecularBeamWavelengthType);
+ setInclinationProperty("SpecularBeamInclinationAxis");
+ setWavelengthProperty("SpecularBeamWavelength");
getItem(P_AZIMUTHAL_ANGLE)->setVisible(false);
getItem(P_POLARIZATION)->setVisible(false);
- auto item = addGroupProperty(P_FOOPTPRINT, Constants::FootprintGroup);
+ auto item = addGroupProperty(P_FOOPTPRINT, "Footprint group");
item->setDisplayName(footprint_group_label);
item->setToolTip("Footprint type");
@@ -199,8 +199,8 @@ void SpecularBeamItem::updateFileName(const QString& filename)
void SpecularBeamItem::updateToData(const IAxis& axis, QString units)
{
- if (units == Constants::UnitsNbins) {
- inclinationAxisGroup()->setCurrentType(Constants::BasicAxisType);
+ if (units == "nbins") {
+ inclinationAxisGroup()->setCurrentType("BasicAxis");
auto axis_item = currentInclinationAxisItem();
axis_item->setItemValue(BasicAxisItem::P_NBINS, static_cast<int>(axis.size()));
return;
@@ -208,9 +208,9 @@ void SpecularBeamItem::updateToData(const IAxis& axis, QString units)
auto axis_group = inclinationAxisGroup();
auto axis_item =
- static_cast<PointwiseAxisItem*>(axis_group->getChildOfType(Constants::PointwiseAxisType));
+ static_cast<PointwiseAxisItem*>(axis_group->getChildOfType("PointwiseAxis"));
axis_item->init(axis, units);
- axis_group->setCurrentType(Constants::PointwiseAxisType); // calls updateWavelength()
+ axis_group->setCurrentType("PointwiseAxis"); // calls updateWavelength()
axis_item->updateIndicators();
}
@@ -220,7 +220,7 @@ void SpecularBeamItem::updateWavelength()
auto wl_item = static_cast<SpecularBeamWavelengthItem*>(getItem(P_WAVELENGTH));
if (auto axis_item = dynamic_cast<PointwiseAxisItem*>(item)) {
auto axis = axis_item->getAxis();
- if (axis && axis_item->getUnitsLabel() == Constants::UnitsQyQz)
+ if (axis && axis_item->getUnitsLabel() == "q-space")
wl_item->setToRange(getLimits(axis->getMax()));
} else
wl_item->setToRange(RealLimits::positive());
@@ -229,10 +229,10 @@ void SpecularBeamItem::updateWavelength()
// GISAS beam item
/* ------------------------------------------------------------------------- */
-GISASBeamItem::GISASBeamItem() : BeamItem(Constants::GISASBeamType)
+GISASBeamItem::GISASBeamItem() : BeamItem("GISASBeam")
{
- setInclinationProperty(Constants::BeamInclinationAngleType);
- setWavelengthProperty(Constants::BeamWavelengthType);
+ setInclinationProperty("BeamInclinationAngle");
+ setWavelengthProperty("BeamWavelength");
}
GISASBeamItem::~GISASBeamItem() = default;
diff --git a/GUI/coregui/Models/BeamWavelengthItem.cpp b/GUI/coregui/Models/BeamWavelengthItem.cpp
index 0ce6b6f04a919937a6039ecab8417445105e98be..1f55f5468da7fb921ca5b1d83588e0ce1e59d7f0 100644
--- a/GUI/coregui/Models/BeamWavelengthItem.cpp
+++ b/GUI/coregui/Models/BeamWavelengthItem.cpp
@@ -28,7 +28,7 @@ BeamWavelengthItem::BeamWavelengthItem(const QString& model_type, const QString&
valueItem->setLimits(RealLimits::positive());
valueItem->setDecimals(4);
valueItem->setValue(default_wl);
- valueItem->setEditorType(Constants::ScientificSpinBoxType);
+ valueItem->setEditorType("ScientificSpinBox");
initDistributionItem(m_show_mean);
}
@@ -41,8 +41,8 @@ double BeamWavelengthItem::wavelength() const
}
SpecularBeamWavelengthItem::SpecularBeamWavelengthItem()
- : BeamWavelengthItem(Constants::SpecularBeamWavelengthType,
- Constants::SymmetricDistributionGroup)
+ : BeamWavelengthItem("SpecularBeamWavelength",
+ "Symmetric distribution group")
{
}
diff --git a/GUI/coregui/Models/BeamWavelengthItem.h b/GUI/coregui/Models/BeamWavelengthItem.h
index a33f1900feb5a125e2e9bc95c5c54483434b42c5..aa47384e4d060e9eb323ce8d5c64f57922b500c9 100644
--- a/GUI/coregui/Models/BeamWavelengthItem.h
+++ b/GUI/coregui/Models/BeamWavelengthItem.h
@@ -20,8 +20,8 @@
class BA_CORE_API_ BeamWavelengthItem : public BeamDistributionItem
{
public:
- BeamWavelengthItem(const QString& model_type = Constants::BeamWavelengthType,
- const QString& distribution_group = Constants::DistributionExtendedGroup);
+ BeamWavelengthItem(const QString& model_type = "BeamWavelength",
+ const QString& distribution_group = "Distribution extended group");
double wavelength() const;
diff --git a/GUI/coregui/Models/ComponentProxyModel.cpp b/GUI/coregui/Models/ComponentProxyModel.cpp
index c8948c8869a2de19e1918680f87b2780fd209d3a..15654e7eb85649affca800f9fe4c3ed75c4f528d 100644
--- a/GUI/coregui/Models/ComponentProxyModel.cpp
+++ b/GUI/coregui/Models/ComponentProxyModel.cpp
@@ -151,7 +151,7 @@ void ComponentProxyModel::sourceDataChanged(const QModelIndex& topLeft,
Q_ASSERT(bottomRight.isValid() ? bottomRight.model() == sourceModel() : true);
if (SessionItem* item = m_model->itemForIndex(topLeft)) {
- if (item->modelType() == Constants::GroupItemType)
+ if (item->modelType() == "GroupProperty")
updateModelMap();
}
dataChanged(mapFromSource(topLeft), mapFromSource(bottomRight), roles);
diff --git a/GUI/coregui/Models/ComponentProxyStrategy.cpp b/GUI/coregui/Models/ComponentProxyStrategy.cpp
index 9f541250cbd754576ea5b0dd2bab6e081f1c6aa8..efdd34e06a04495a5db43c50f622659bc3e4b65b 100644
--- a/GUI/coregui/Models/ComponentProxyStrategy.cpp
+++ b/GUI/coregui/Models/ComponentProxyStrategy.cpp
@@ -64,7 +64,7 @@ bool ComponentProxyStrategy::isPropertyRelated(SessionItem* item)
static QStringList propertyRelated = ComponentUtils::propertyRelatedTypes();
if (m_sourceRootIndex.isValid() && item->parent()->index() == m_sourceRootIndex
- && item->parent()->modelType() != Constants::GroupItemType)
+ && item->parent()->modelType() != "GroupProperty")
return propertyRelated.contains(item->modelType()) ? true : false;
return true;
@@ -93,9 +93,9 @@ void ComponentProxyStrategy::processRootItem(SessionItem* item,
bool ComponentProxyStrategy::isSubGroup(SessionItem* item)
{
- const SessionItem* ancestor = ModelPath::ancestor(item->parent(), Constants::GroupItemType);
- if (item->modelType() == Constants::GroupItemType && ancestor
- && ancestor->modelType() == Constants::GroupItemType) {
+ const SessionItem* ancestor = ModelPath::ancestor(item->parent(), "GroupProperty");
+ if (item->modelType() == "GroupProperty" && ancestor
+ && ancestor->modelType() == "GroupProperty") {
return true;
}
@@ -106,10 +106,10 @@ bool ComponentProxyStrategy::isSubGroup(SessionItem* item)
bool ComponentProxyStrategy::isGroupChildren(SessionItem* item)
{
- if (item->parent() && item->parent()->modelType() == Constants::GroupItemType)
+ if (item->parent() && item->parent()->modelType() == "GroupProperty")
return true;
- if (const SessionItem* ancestor = ModelPath::ancestor(item, Constants::GroupItemType)) {
+ if (const SessionItem* ancestor = ModelPath::ancestor(item, "GroupProperty")) {
if (ancestor != item)
return true;
}
@@ -122,7 +122,7 @@ bool ComponentProxyStrategy::isGroupChildren(SessionItem* item)
void ComponentProxyStrategy::processGroupItem(SessionItem* item,
const QPersistentModelIndex& sourceIndex)
{
- if (const SessionItem* ancestor = ModelPath::ancestor(item, Constants::GroupItemType)) {
+ if (const SessionItem* ancestor = ModelPath::ancestor(item, "GroupProperty")) {
if (ancestor == item)
return;
@@ -143,7 +143,7 @@ void ComponentProxyStrategy::processSubGroupItem(SessionItem* item,
const QPersistentModelIndex& sourceIndex)
{
if (const SessionItem* ancestor =
- ModelPath::ancestor(item->parent(), Constants::GroupItemType)) {
+ ModelPath::ancestor(item->parent(), "GroupProperty")) {
auto groupItem = dynamic_cast<const GroupItem*>(ancestor);
if (item->parent() == groupItem->currentItem()) {
diff --git a/GUI/coregui/Models/Data1DViewItem.cpp b/GUI/coregui/Models/Data1DViewItem.cpp
index c00349f1c1e7b6bb75fa04cb43a1d3af02bb2e36..1aa8d5e74cc2d9a8417cc5eb0006e447178471ee 100644
--- a/GUI/coregui/Models/Data1DViewItem.cpp
+++ b/GUI/coregui/Models/Data1DViewItem.cpp
@@ -37,14 +37,14 @@ const QString Data1DViewItem::P_YAXIS = "y-axis";
const QString Data1DViewItem::P_AXES_UNITS = "Axes Units";
const QString Data1DViewItem::T_DATA_PROPERTIES = "Data property container";
-Data1DViewItem::Data1DViewItem() : SessionItem(Constants::Data1DViewItemType), m_job_item(nullptr)
+Data1DViewItem::Data1DViewItem() : SessionItem("Data1DViewItem"), m_job_item(nullptr)
{
addProperty(P_TITLE, QString())->setVisible(false);
- SessionItem* item = addGroupProperty(P_XAXIS, Constants::BasicAxisType);
+ SessionItem* item = addGroupProperty(P_XAXIS, "BasicAxis");
item->getItem(BasicAxisItem::P_NBINS)->setVisible(false);
- item = addGroupProperty(P_YAXIS, Constants::AmplitudeAxisType);
+ item = addGroupProperty(P_YAXIS, "AmplitudeAxis");
item->getItem(BasicAxisItem::P_NBINS)->setVisible(false);
item->getItem(BasicAxisItem::P_TITLE)->setVisible(true);
@@ -52,9 +52,9 @@ Data1DViewItem::Data1DViewItem() : SessionItem(Constants::Data1DViewItemType), m
item->setValue(true);
item->setVisible(false);
- registerTag(T_DATA_PROPERTIES, 1, 1, QStringList() << Constants::DataPropertyContainerType);
+ registerTag(T_DATA_PROPERTIES, 1, 1, QStringList() << "DataPropertyContainer");
- ComboProperty combo = ComboProperty() << Constants::UnitsNbins;
+ ComboProperty combo = ComboProperty() << "nbins";
addProperty(P_AXES_UNITS, combo.variant());
mapper()->setOnPropertyChange([this](const QString& name) {
@@ -171,7 +171,7 @@ JobItem* Data1DViewItem::jobItem()
auto item = parent();
do {
- if (item->modelType() == Constants::JobItemType) {
+ if (item->modelType() == "JobItem") {
m_job_item = dynamic_cast<JobItem*>(item);
return m_job_item;
}
diff --git a/GUI/coregui/Models/DataItem.cpp b/GUI/coregui/Models/DataItem.cpp
index 21beda32ec2b1af1fe58c3dacf25198dbb95f88e..7090a231c713c142b7b8fbccc5eb19c7ab39b42e 100644
--- a/GUI/coregui/Models/DataItem.cpp
+++ b/GUI/coregui/Models/DataItem.cpp
@@ -90,7 +90,7 @@ DataItem::DataItem(const QString& modelType) : SessionItem(modelType)
// name of the file used to serialize given IntensityDataItem
addProperty(P_FILE_NAME, QStringLiteral("undefined"))->setVisible(false);
- ComboProperty units = ComboProperty() << Constants::UnitsNbins;
+ ComboProperty units = ComboProperty() << "nbins";
addProperty(P_AXES_UNITS, units.variant());
mapper()->setOnPropertyChange([this](const QString& name) {
diff --git a/GUI/coregui/Models/DataItemUtils.cpp b/GUI/coregui/Models/DataItemUtils.cpp
index a0be9c955c3532009a556e8801a9bd4a6a9ff3f8..a4a618af617cdc5c2ab7d6ece9c86c3f49eb241e 100644
--- a/GUI/coregui/Models/DataItemUtils.cpp
+++ b/GUI/coregui/Models/DataItemUtils.cpp
@@ -25,7 +25,7 @@ template <class DataItemType> DataItemType* dataItem(SessionItem* parent)
{
assert(parent && "Assertion failed in DataItemUtils::dataItem: nullptr passed.");
- if (parent->modelType() == Constants::JobItemType)
+ if (parent->modelType() == "JobItem")
return dynamic_cast<DataItemType*>(parent->getItem(JobItem::T_OUTPUT));
else if (auto real_data = dynamic_cast<RealDataItem*>(parent))
return dynamic_cast<DataItemType*>(real_data->dataItem());
diff --git a/GUI/coregui/Models/DataProperties.cpp b/GUI/coregui/Models/DataProperties.cpp
index 9000cef6fd7465ac57f6061a3beb47f1aa387428..000829f5e404b3e17c7ccdb5352f1dda81023a07 100644
--- a/GUI/coregui/Models/DataProperties.cpp
+++ b/GUI/coregui/Models/DataProperties.cpp
@@ -70,7 +70,7 @@ DataItem* DataProperties::dataItem()
const QString Data1DProperties::P_COLOR = "Color";
-Data1DProperties::Data1DProperties() : DataProperties(Constants::DataItem1DPropertiesType)
+Data1DProperties::Data1DProperties() : DataProperties("DataItem1DProperties")
{
addProperty(P_COLOR, defaultColorCombo().variant());
}
diff --git a/GUI/coregui/Models/DataPropertyContainer.cpp b/GUI/coregui/Models/DataPropertyContainer.cpp
index 054c3e3b13369a03f920eb705e6c99e99f473621..632d636ec3e42ceb0e28583bb1cf14895feb5733 100644
--- a/GUI/coregui/Models/DataPropertyContainer.cpp
+++ b/GUI/coregui/Models/DataPropertyContainer.cpp
@@ -19,9 +19,9 @@
const QString DataPropertyContainer::T_CHILDREN = "data links";
-DataPropertyContainer::DataPropertyContainer() : SessionItem(Constants::DataPropertyContainerType)
+DataPropertyContainer::DataPropertyContainer() : SessionItem("DataPropertyContainer")
{
- registerTag(T_CHILDREN, 0, -1, QStringList() << Constants::DataItem1DPropertiesType);
+ registerTag(T_CHILDREN, 0, -1, QStringList() << "DataItem1DProperties");
setDefaultTag(T_CHILDREN);
}
diff --git a/GUI/coregui/Models/DepthProbeInstrumentItem.cpp b/GUI/coregui/Models/DepthProbeInstrumentItem.cpp
index 22d35b86325f21da15771d0c80c12f7efee1c772..33a16922ca7d14654efff8038bceb14dbe72f43d 100644
--- a/GUI/coregui/Models/DepthProbeInstrumentItem.cpp
+++ b/GUI/coregui/Models/DepthProbeInstrumentItem.cpp
@@ -26,18 +26,18 @@ const QString DepthProbeInstrumentItem::P_BEAM = "Beam";
const QString DepthProbeInstrumentItem::P_ZAXIS = "Z axis";
DepthProbeInstrumentItem::DepthProbeInstrumentItem()
- : InstrumentItem(Constants::DepthProbeInstrumentType)
+ : InstrumentItem("DepthProbeInstrument")
{
- setItemName(Constants::DepthProbeInstrumentType);
+ setItemName("DepthProbeInstrument");
- addGroupProperty(P_BEAM, Constants::SpecularBeamType);
+ addGroupProperty(P_BEAM, "SpecularBeam");
auto axisItem = beamItem()->currentInclinationAxisItem();
axisItem->setItemValue(BasicAxisItem::P_MIN, 0.0);
axisItem->setItemValue(BasicAxisItem::P_MAX, 1.0);
axisItem->setItemValue(BasicAxisItem::P_NBINS, 500);
- auto axis = addGroupProperty(P_ZAXIS, Constants::BasicAxisType);
+ auto axis = addGroupProperty(P_ZAXIS, "BasicAxis");
axis->getItem(BasicAxisItem::P_TITLE)->setVisible(false);
axis->setItemValue(BasicAxisItem::P_MIN, -100.0);
axis->setItemValue(BasicAxisItem::P_MAX, 100.0);
diff --git a/GUI/coregui/Models/DetectorItems.cpp b/GUI/coregui/Models/DetectorItems.cpp
index a56b4ad1f158030332d6bfa91d90b37d007b67a8..ff5bb760ed85532be3355a97e6fc3b1d285aa554 100644
--- a/GUI/coregui/Models/DetectorItems.cpp
+++ b/GUI/coregui/Models/DetectorItems.cpp
@@ -39,10 +39,10 @@ const QString DetectorItem::P_ANALYZER_TOTAL_TRANSMISSION = QString::fromStdStri
DetectorItem::DetectorItem(const QString& modelType) : SessionItem(modelType)
{
- registerTag(T_MASKS, 0, -1, QStringList() << Constants::MaskContainerType);
+ registerTag(T_MASKS, 0, -1, QStringList() << "MaskContainer");
setDefaultTag(T_MASKS);
- addGroupProperty(P_ANALYZER_DIRECTION, Constants::VectorType)
+ addGroupProperty(P_ANALYZER_DIRECTION, "Vector")
->setToolTip(analyzer_direction_tooltip);
addProperty(P_ANALYZER_EFFICIENCY, 0.0)
->setLimits(RealLimits::limitless())
@@ -91,7 +91,7 @@ MaskContainerItem* DetectorItem::maskContainerItem() const
void DetectorItem::createMaskContainer()
{
if (!maskContainerItem())
- model()->insertNewItem(Constants::MaskContainerType, this->index());
+ model()->insertNewItem("MaskContainer", this->index());
}
void DetectorItem::importMasks(const MaskContainerItem* maskContainer)
@@ -104,7 +104,7 @@ void DetectorItem::importMasks(const MaskContainerItem* maskContainer)
void DetectorItem::register_resolution_function()
{
- auto item = addGroupProperty(P_RESOLUTION_FUNCTION, Constants::ResolutionFunctionGroup);
+ auto item = addGroupProperty(P_RESOLUTION_FUNCTION, "Resolution function group");
item->setDisplayName(res_func_group_label);
item->setToolTip("Detector resolution function");
}
@@ -113,8 +113,8 @@ void DetectorItem::update_resolution_function_tooltips()
{
auto& resfuncItem = groupItem<ResolutionFunctionItem>(DetectorItem::P_RESOLUTION_FUNCTION);
- if (resfuncItem.modelType() == Constants::ResolutionFunction2DGaussianType) {
- QString units = modelType() == Constants::SphericalDetectorType ? "deg" : "mm";
+ if (resfuncItem.modelType() == "ResolutionFunction2DGaussian") {
+ QString units = modelType() == "SphericalDetector" ? "deg" : "mm";
resfuncItem.getItem(ResolutionFunction2DGaussianItem::P_SIGMA_X)
->setToolTip("Resolution along horizontal axis (in " + units + ")");
@@ -141,7 +141,7 @@ void DetectorItem::addMasksToDomain(IDetector2D* detector) const
for (int i_row = maskContainer->children().size(); i_row > 0; --i_row) {
if (auto maskItem = dynamic_cast<MaskItem*>(maskContainer->children().at(i_row - 1))) {
- if (maskItem->modelType() == Constants::RegionOfInterestType) {
+ if (maskItem->modelType() == "RegionOfInterest") {
double xlow = scale * maskItem->getItemValue(RectangleItem::P_XLOW).toDouble();
double ylow = scale * maskItem->getItemValue(RectangleItem::P_YLOW).toDouble();
double xup = scale * maskItem->getItemValue(RectangleItem::P_XUP).toDouble();
diff --git a/GUI/coregui/Models/DistributionItems.cpp b/GUI/coregui/Models/DistributionItems.cpp
index 6953f8710ac9b0cc54ddc1944d76130051a7abf9..5e2eb090af6a5325c337c31f6559bde16d426a39 100644
--- a/GUI/coregui/Models/DistributionItems.cpp
+++ b/GUI/coregui/Models/DistributionItems.cpp
@@ -26,7 +26,7 @@ createRangedDistribution(const SymmetricDistributionItem& distr_item, double sca
}
const QString DistributionItem::P_NUMBER_OF_SAMPLES = "Number of samples";
-const QString DistributionItem::P_SIGMA_FACTOR = Constants::DistributionSigmaFactor;
+const QString DistributionItem::P_SIGMA_FACTOR = "Sigma factor";
const QString DistributionItem::P_IS_INITIALIZED = "is initialized";
const QString DistributionItem::P_LIMITS = "Limits";
@@ -54,19 +54,19 @@ void DistributionItem::init_limits_group(const RealLimits& limits, double factor
if (!isTag(P_LIMITS))
return;
if (limits.isLimitless()) {
- setGroupProperty(P_LIMITS, Constants::RealLimitsLimitlessType);
+ setGroupProperty(P_LIMITS, "RealLimitsLimitless");
} else if (limits.isPositive()) {
- setGroupProperty(P_LIMITS, Constants::RealLimitsPositiveType);
+ setGroupProperty(P_LIMITS, "RealLimitsPositive");
} else if (limits.isNonnegative()) {
- setGroupProperty(P_LIMITS, Constants::RealLimitsNonnegativeType);
+ setGroupProperty(P_LIMITS, "RealLimitsNonnegative");
} else if (limits.isLowerLimited()) {
- SessionItem* lim = setGroupProperty(P_LIMITS, Constants::RealLimitsLowerLimitedType);
+ SessionItem* lim = setGroupProperty(P_LIMITS, "RealLimitsLowerLimited");
lim->setItemValue(RealLimitsItem::P_XMIN, limits.lowerLimit() * factor);
} else if (limits.isUpperLimited()) {
- SessionItem* lim = setGroupProperty(P_LIMITS, Constants::RealLimitsUpperLimitedType);
+ SessionItem* lim = setGroupProperty(P_LIMITS, "RealLimitsUpperLimited");
lim->setItemValue(RealLimitsItem::P_XMAX, limits.upperLimit() * factor);
} else if (limits.isLimited()) {
- SessionItem* lim = setGroupProperty(P_LIMITS, Constants::RealLimitsLimitedType);
+ SessionItem* lim = setGroupProperty(P_LIMITS, "RealLimitsLimited");
lim->setItemValue(RealLimitsItem::P_XMIN, limits.lowerLimit() * factor);
lim->setItemValue(RealLimitsItem::P_XMAX, limits.upperLimit() * factor);
}
@@ -84,8 +84,8 @@ void DistributionItem::register_sigma_factor()
void DistributionItem::register_limits()
{
- addGroupProperty(P_LIMITS, Constants::RealLimitsGroup);
- setGroupProperty(P_LIMITS, Constants::RealLimitsLimitlessType);
+ addGroupProperty(P_LIMITS, "RealLimits group");
+ setGroupProperty(P_LIMITS, "RealLimitsLimitless");
}
// --------------------------------------------------------------------------------------------- //
@@ -104,7 +104,7 @@ void SymmetricDistributionItem::showMean(bool flag)
// --------------------------------------------------------------------------------------------- //
DistributionNoneItem::DistributionNoneItem()
- : SymmetricDistributionItem(Constants::DistributionNoneType)
+ : SymmetricDistributionItem("DistributionNone")
{
addProperty(P_MEAN, 0.1)->setLimits(RealLimits::limitless()).setDisplayName("Value");
getItem(P_MEAN)->setDecimals(4);
@@ -136,7 +136,7 @@ void DistributionNoneItem::init_distribution(double value)
const QString DistributionGateItem::P_MIN = QString::fromStdString("Min");
const QString DistributionGateItem::P_MAX = QString::fromStdString("Max");
-DistributionGateItem::DistributionGateItem() : DistributionItem(Constants::DistributionGateType)
+DistributionGateItem::DistributionGateItem() : DistributionItem("DistributionGate")
{
addProperty(P_MIN, 0.0)->setLimits(RealLimits::limitless());
addProperty(P_MAX, 1.0)->setLimits(RealLimits::limitless());
@@ -166,7 +166,7 @@ void DistributionGateItem::init_distribution(double value)
const QString DistributionLorentzItem::P_HWHM = QString::fromStdString("HWHM");
DistributionLorentzItem::DistributionLorentzItem()
- : SymmetricDistributionItem(Constants::DistributionLorentzType)
+ : SymmetricDistributionItem("DistributionLorentz")
{
addProperty(P_MEAN, 1.0)->setLimits(RealLimits::limitless());
addProperty(P_HWHM, 1.0);
@@ -209,7 +209,7 @@ void DistributionLorentzItem::init_distribution(double value)
const QString DistributionGaussianItem::P_STD_DEV = QString::fromStdString("StdDev");
DistributionGaussianItem::DistributionGaussianItem()
- : SymmetricDistributionItem(Constants::DistributionGaussianType)
+ : SymmetricDistributionItem("DistributionGaussian")
{
addProperty(P_MEAN, 1.0)->setLimits(RealLimits::limitless());
addProperty(P_STD_DEV, 1.0);
@@ -253,7 +253,7 @@ const QString DistributionLogNormalItem::P_MEDIAN = QString::fromStdString("Medi
const QString DistributionLogNormalItem::P_SCALE_PAR = QString::fromStdString("ScaleParameter");
DistributionLogNormalItem::DistributionLogNormalItem()
- : DistributionItem(Constants::DistributionLogNormalType)
+ : DistributionItem("DistributionLogNormal")
{
addProperty(P_MEDIAN, 1.0);
addProperty(P_SCALE_PAR, 1.0);
@@ -290,7 +290,7 @@ void DistributionLogNormalItem::showMean(bool flag)
const QString DistributionCosineItem::P_SIGMA = QString::fromStdString("Sigma");
DistributionCosineItem::DistributionCosineItem()
- : SymmetricDistributionItem(Constants::DistributionCosineType)
+ : SymmetricDistributionItem("DistributionCosine")
{
addProperty(P_MEAN, 1.0)->setLimits(RealLimits::limitless());
addProperty(P_SIGMA, 1.0);
@@ -336,7 +336,7 @@ const QString DistributionTrapezoidItem::P_MIDDLEWIDTH = QString::fromStdString(
const QString DistributionTrapezoidItem::P_RIGHTWIDTH = QString::fromStdString("RightWidth");
DistributionTrapezoidItem::DistributionTrapezoidItem()
- : DistributionItem(Constants::DistributionTrapezoidType)
+ : DistributionItem("DistributionTrapezoid")
{
addProperty(P_CENTER, 1.0)->setLimits(RealLimits::limitless());
addProperty(P_LEFTWIDTH, 1.0);
diff --git a/GUI/coregui/Models/DomainObjectBuilder.cpp b/GUI/coregui/Models/DomainObjectBuilder.cpp
index d832ce4f59a2c5b370672f875dffb28a0fec5426..8d6a60cb54c53c52c3c3a6a4a6ac02c7156a8066 100644
--- a/GUI/coregui/Models/DomainObjectBuilder.cpp
+++ b/GUI/coregui/Models/DomainObjectBuilder.cpp
@@ -36,7 +36,7 @@ std::unique_ptr<MultiLayer> DomainObjectBuilder::buildMultiLayer(const SessionIt
auto P_multilayer = TransformToDomain::createMultiLayer(multilayer_item);
QVector<SessionItem*> children = multilayer_item.children();
for (int i = 0; i < children.size(); ++i) {
- if (children[i]->modelType() == Constants::LayerType) {
+ if (children[i]->modelType() == "Layer") {
auto P_layer = buildLayer(*children[i]);
auto roughnessItem = children[i]->getGroupItem(LayerItem::P_ROUGHNESS);
Q_ASSERT(roughnessItem);
@@ -58,7 +58,7 @@ std::unique_ptr<Layer> DomainObjectBuilder::buildLayer(const SessionItem& item)
auto P_layer = TransformToDomain::createLayer(item);
QVector<SessionItem*> children = item.children();
for (int i = 0; i < children.size(); ++i) {
- if (children[i]->modelType() == Constants::ParticleLayoutType) {
+ if (children[i]->modelType() == "ParticleLayout") {
auto P_layout = buildParticleLayout(*children[i]);
if (P_layout) {
P_layer->addLayout(*P_layout);
@@ -78,7 +78,7 @@ std::unique_ptr<ParticleLayout> DomainObjectBuilder::buildParticleLayout(const S
P_layout->addParticle(*P_particle);
continue;
}
- if (children[i]->modelType() == Constants::ParticleDistributionType) {
+ if (children[i]->modelType() == "ParticleDistribution") {
auto prop = children[i]
->getItemValue(ParticleDistributionItem::P_DISTRIBUTED_PARAMETER)
.value<ComboProperty>();
@@ -143,10 +143,10 @@ DomainObjectBuilder::createUnitConverter(const InstrumentItem* instrumentItem)
const auto instrument = instrumentItem->createInstrument();
instrument->initDetector();
- if (instrumentItem->modelType() == Constants::GISASInstrumentType)
+ if (instrumentItem->modelType() == "GISASInstrument")
return UnitConverterUtils::createConverterForGISAS(*instrument);
- if (instrumentItem->modelType() == Constants::OffSpecInstrumentType) {
+ if (instrumentItem->modelType() == "OffSpecInstrument") {
auto axis_item = dynamic_cast<BasicAxisItem*>(
instrumentItem->getItem(OffSpecInstrumentItem::P_ALPHA_AXIS));
const auto detector2d = dynamic_cast<const IDetector2D*>(instrument->getDetector());
diff --git a/GUI/coregui/Models/FTDecayFunctionItems.cpp b/GUI/coregui/Models/FTDecayFunctionItems.cpp
index 063499235018af3b5fac3104c9737751cd653570..7383827685c6c44329939f4aaa3875835eda4970 100644
--- a/GUI/coregui/Models/FTDecayFunctionItems.cpp
+++ b/GUI/coregui/Models/FTDecayFunctionItems.cpp
@@ -30,7 +30,7 @@ void FTDecayFunction1DItem::add_decay_property()
// --------------------------------------------------------------------------------------------- //
FTDecayFunction1DCauchyItem::FTDecayFunction1DCauchyItem()
- : FTDecayFunction1DItem(Constants::FTDecayFunction1DCauchyType)
+ : FTDecayFunction1DItem("FTDecayFunction1DCauchy")
{
setToolTip(QStringLiteral("One-dimensional Cauchy decay function"));
add_decay_property();
@@ -44,7 +44,7 @@ std::unique_ptr<IFTDecayFunction1D> FTDecayFunction1DCauchyItem::createFTDecayFu
// --------------------------------------------------------------------------------------------- //
FTDecayFunction1DGaussItem::FTDecayFunction1DGaussItem()
- : FTDecayFunction1DItem(Constants::FTDecayFunction1DGaussType)
+ : FTDecayFunction1DItem("FTDecayFunction1DGauss")
{
setToolTip(QStringLiteral("One-dimensional Gauss decay function"));
add_decay_property();
@@ -58,7 +58,7 @@ std::unique_ptr<IFTDecayFunction1D> FTDecayFunction1DGaussItem::createFTDecayFun
// --------------------------------------------------------------------------------------------- //
FTDecayFunction1DTriangleItem::FTDecayFunction1DTriangleItem()
- : FTDecayFunction1DItem(Constants::FTDecayFunction1DTriangleType)
+ : FTDecayFunction1DItem("FTDecayFunction1DTriangle")
{
setToolTip(QStringLiteral("One-dimensional triangle decay function"));
add_decay_property();
@@ -74,7 +74,7 @@ std::unique_ptr<IFTDecayFunction1D> FTDecayFunction1DTriangleItem::createFTDecay
const QString FTDecayFunction1DVoigtItem::P_ETA = QString::fromStdString("Eta");
FTDecayFunction1DVoigtItem::FTDecayFunction1DVoigtItem()
- : FTDecayFunction1DItem(Constants::FTDecayFunction1DVoigtType)
+ : FTDecayFunction1DItem("FTDecayFunction1DVoigt")
{
setToolTip(QStringLiteral("One-dimensional pseudo-Voigt decay function"));
add_decay_property();
@@ -120,7 +120,7 @@ void FTDecayFunction2DItem::add_gammadelta_property()
// --------------------------------------------------------------------------------------------- //
FTDecayFunction2DCauchyItem::FTDecayFunction2DCauchyItem()
- : FTDecayFunction2DItem(Constants::FTDecayFunction2DCauchyType)
+ : FTDecayFunction2DItem("FTDecayFunction2DCauchy")
{
setToolTip(QStringLiteral("Two-dimensional Cauchy decay function"));
add_decay_property();
@@ -137,7 +137,7 @@ std::unique_ptr<IFTDecayFunction2D> FTDecayFunction2DCauchyItem::createFTDecayFu
// --------------------------------------------------------------------------------------------- //
FTDecayFunction2DGaussItem::FTDecayFunction2DGaussItem()
- : FTDecayFunction2DItem(Constants::FTDecayFunction2DGaussType)
+ : FTDecayFunction2DItem("FTDecayFunction2DGauss")
{
setToolTip(QStringLiteral("Two-dimensional Gauss decay function"));
add_decay_property();
@@ -156,7 +156,7 @@ std::unique_ptr<IFTDecayFunction2D> FTDecayFunction2DGaussItem::createFTDecayFun
const QString FTDecayFunction2DVoigtItem::P_ETA = QString::fromStdString("Eta");
FTDecayFunction2DVoigtItem::FTDecayFunction2DVoigtItem()
- : FTDecayFunction2DItem(Constants::FTDecayFunction2DVoigtType)
+ : FTDecayFunction2DItem("FTDecayFunction2DVoigt")
{
setToolTip(QStringLiteral("Two-dimensional pseudo-Voigt decay function"));
add_decay_property();
diff --git a/GUI/coregui/Models/FTDistributionItems.cpp b/GUI/coregui/Models/FTDistributionItems.cpp
index 24bd25ed225770072b8ef57b8952a1d9c03faf16..ddb36c1ace793d7fa2744acc9666332b20aab789 100644
--- a/GUI/coregui/Models/FTDistributionItems.cpp
+++ b/GUI/coregui/Models/FTDistributionItems.cpp
@@ -28,7 +28,7 @@ void FTDistribution1DItem::add_omega_property()
// --------------------------------------------------------------------------------------------- //
FTDistribution1DCauchyItem::FTDistribution1DCauchyItem()
- : FTDistribution1DItem(Constants::FTDistribution1DCauchyType)
+ : FTDistribution1DItem("FTDistribution1DCauchy")
{
setToolTip(QStringLiteral("One-dimensional Cauchy probability distribution"));
add_omega_property();
@@ -42,7 +42,7 @@ std::unique_ptr<IFTDistribution1D> FTDistribution1DCauchyItem::createFTDistribut
// --------------------------------------------------------------------------------------------- //
FTDistribution1DGaussItem::FTDistribution1DGaussItem()
- : FTDistribution1DItem(Constants::FTDistribution1DGaussType)
+ : FTDistribution1DItem("FTDistribution1DGauss")
{
setToolTip(QStringLiteral("One-dimensional Gauss probability distribution"));
add_omega_property();
@@ -56,7 +56,7 @@ std::unique_ptr<IFTDistribution1D> FTDistribution1DGaussItem::createFTDistributi
// --------------------------------------------------------------------------------------------- //
FTDistribution1DGateItem::FTDistribution1DGateItem()
- : FTDistribution1DItem(Constants::FTDistribution1DGateType)
+ : FTDistribution1DItem("FTDistribution1DGate")
{
setToolTip(QStringLiteral("One-dimensional Gate probability distribution"));
add_omega_property();
@@ -70,7 +70,7 @@ std::unique_ptr<IFTDistribution1D> FTDistribution1DGateItem::createFTDistributio
// --------------------------------------------------------------------------------------------- //
FTDistribution1DTriangleItem::FTDistribution1DTriangleItem()
- : FTDistribution1DItem(Constants::FTDistribution1DTriangleType)
+ : FTDistribution1DItem("FTDistribution1DTriangle")
{
setToolTip(QStringLiteral("One-dimensional triangle probability distribution"));
add_omega_property();
@@ -84,7 +84,7 @@ std::unique_ptr<IFTDistribution1D> FTDistribution1DTriangleItem::createFTDistrib
// --------------------------------------------------------------------------------------------- //
FTDistribution1DCosineItem::FTDistribution1DCosineItem()
- : FTDistribution1DItem(Constants::FTDistribution1DCosineType)
+ : FTDistribution1DItem("FTDistribution1DCosine")
{
setToolTip(QStringLiteral("One-dimensional Cosine probability distribution"));
add_omega_property();
@@ -100,7 +100,7 @@ std::unique_ptr<IFTDistribution1D> FTDistribution1DCosineItem::createFTDistribut
const QString FTDistribution1DVoigtItem::P_ETA = QString::fromStdString("Eta");
FTDistribution1DVoigtItem::FTDistribution1DVoigtItem()
- : FTDistribution1DItem(Constants::FTDistribution1DVoigtType)
+ : FTDistribution1DItem("FTDistribution1DVoigt")
{
setToolTip(QStringLiteral("One-dimensional pseudo-Voigt probability distribution"));
add_omega_property();
@@ -151,7 +151,7 @@ void FTDistribution2DItem::add_properties()
// --------------------------------------------------------------------------------------------- //
FTDistribution2DCauchyItem::FTDistribution2DCauchyItem()
- : FTDistribution2DItem(Constants::FTDistribution2DCauchyType)
+ : FTDistribution2DItem("FTDistribution2DCauchy")
{
setToolTip(QStringLiteral("Two-dimensional Cauchy probability distribution"));
add_properties();
@@ -167,7 +167,7 @@ std::unique_ptr<IFTDistribution2D> FTDistribution2DCauchyItem::createFTDistribut
// --------------------------------------------------------------------------------------------- //
FTDistribution2DGaussItem::FTDistribution2DGaussItem()
- : FTDistribution2DItem(Constants::FTDistribution2DGaussType)
+ : FTDistribution2DItem("FTDistribution2DGauss")
{
setToolTip(QStringLiteral("Two-dimensional Gauss probability distribution"));
add_properties();
@@ -183,7 +183,7 @@ std::unique_ptr<IFTDistribution2D> FTDistribution2DGaussItem::createFTDistributi
// --------------------------------------------------------------------------------------------- //
FTDistribution2DGateItem::FTDistribution2DGateItem()
- : FTDistribution2DItem(Constants::FTDistribution2DGateType)
+ : FTDistribution2DItem("FTDistribution2DGate")
{
setToolTip(QStringLiteral("Two-dimensional Gate probability distribution"));
add_properties();
@@ -199,7 +199,7 @@ std::unique_ptr<IFTDistribution2D> FTDistribution2DGateItem::createFTDistributio
// --------------------------------------------------------------------------------------------- //
FTDistribution2DConeItem::FTDistribution2DConeItem()
- : FTDistribution2DItem(Constants::FTDistribution2DConeType)
+ : FTDistribution2DItem("FTDistribution2DCone")
{
setToolTip(QStringLiteral("Two-dimensional Cone probability distribution"));
add_properties();
@@ -217,7 +217,7 @@ std::unique_ptr<IFTDistribution2D> FTDistribution2DConeItem::createFTDistributio
const QString FTDistribution2DVoigtItem::P_ETA = QString::fromStdString("Eta");
FTDistribution2DVoigtItem::FTDistribution2DVoigtItem()
- : FTDistribution2DItem(Constants::FTDistribution2DVoigtType)
+ : FTDistribution2DItem("FTDistribution2DVoigt")
{
setToolTip(QStringLiteral("Two-dimensional pseudo-Voigt probability distribution"));
diff --git a/GUI/coregui/Models/FilterPropertyProxy.cpp b/GUI/coregui/Models/FilterPropertyProxy.cpp
index 21a2d38d3e6483ff05df7a29283c3af9b2a13f1f..2f8629682a2749057a267542652dcce2ad757d9c 100644
--- a/GUI/coregui/Models/FilterPropertyProxy.cpp
+++ b/GUI/coregui/Models/FilterPropertyProxy.cpp
@@ -36,8 +36,8 @@ bool FilterPropertyProxy::filterAcceptsRow(int sourceRow, const QModelIndex& sou
if (!sourceParent.isValid())
return true;
const QString modelType = index.data(SessionFlags::ModelTypeRole).toString();
- if (modelType == Constants::PropertyType || modelType == Constants::GroupItemType
- || modelType == Constants::VectorType)
+ if (modelType == "Property" || modelType == "GroupProperty"
+ || modelType == "Vector")
return false;
return true; //! sourceModel()->data(index, Qt::DisplayRole).isValid();
diff --git a/GUI/coregui/Models/FitParameterHelper.cpp b/GUI/coregui/Models/FitParameterHelper.cpp
index 0acdd6dd1ef9d78f9a74e57dd4ad390f969a4e78..6a6e0e59e513649bc7022262103919ef2ad5abf8 100644
--- a/GUI/coregui/Models/FitParameterHelper.cpp
+++ b/GUI/coregui/Models/FitParameterHelper.cpp
@@ -31,11 +31,11 @@ void FitParameterHelper::createFitParameter(FitParameterContainerItem* container
removeFromFitParameters(container, parameterItem);
FitParameterItem* fitPar = dynamic_cast<FitParameterItem*>(
- container->model()->insertNewItem(Constants::FitParameterType, container->index()));
+ container->model()->insertNewItem("FitParameter", container->index()));
Q_ASSERT(fitPar);
fitPar->setDisplayName(QStringLiteral("par"));
SessionItem* link =
- fitPar->model()->insertNewItem(Constants::FitParameterLinkType, fitPar->index());
+ fitPar->model()->insertNewItem("FitParameterLink", fitPar->index());
fitPar->setItemValue(FitParameterItem::P_START_VALUE, parameterItem->value());
link->setItemValue(FitParameterLinkItem::P_LINK, getParameterItemPath(parameterItem));
@@ -72,7 +72,7 @@ void FitParameterHelper::addToFitParameter(FitParameterContainerItem* container,
for (auto fitPar : container->getItems(FitParameterContainerItem::T_FIT_PARAMETERS)) {
if (fitPar->displayName() == fitParName) {
SessionItem* link =
- fitPar->model()->insertNewItem(Constants::FitParameterLinkType, fitPar->index());
+ fitPar->model()->insertNewItem("FitParameterLink", fitPar->index());
link->setItemValue(FitParameterLinkItem::P_LINK, getParameterItemPath(parameterItem));
break;
}
@@ -105,7 +105,7 @@ QStringList FitParameterHelper::getFitParameterNames(FitParameterContainerItem*
QString FitParameterHelper::getParameterItemPath(const ParameterItem* parameterItem)
{
QString result = ModelPath::getPathFromIndex(parameterItem->index());
- QString containerPrefix = Constants::ParameterContainerType + "/";
+ QString containerPrefix = "Parameter Container/";
int containerEnd = result.indexOf(containerPrefix) + containerPrefix.size();
result = result.mid(containerEnd);
return result;
@@ -118,10 +118,10 @@ ParameterItem* FitParameterHelper::getParameterItem(FitParameterContainerItem* c
const QString& link)
{
SessionItem* cur = container;
- while (cur && cur->modelType() != Constants::JobItemType) {
+ while (cur && cur->modelType() != "JobItem") {
cur = cur->parent();
}
- Q_ASSERT(cur && cur->modelType() == Constants::JobItemType);
+ Q_ASSERT(cur && cur->modelType() == "JobItem");
JobItem* jobItem = dynamic_cast<JobItem*>(cur);
Q_ASSERT(jobItem);
return dynamic_cast<ParameterItem*>(
diff --git a/GUI/coregui/Models/FitParameterItems.cpp b/GUI/coregui/Models/FitParameterItems.cpp
index 7a8d5c342425c78fa0d8fdb02e8a65c1201a89b3..995040ba9a161b513e6888594e1e84ceda1b7b07 100644
--- a/GUI/coregui/Models/FitParameterItems.cpp
+++ b/GUI/coregui/Models/FitParameterItems.cpp
@@ -34,9 +34,9 @@ ComboProperty fitParameterTypeCombo()
<< QStringLiteral("No limits imposed to parameter value");
ComboProperty result;
- result << Constants::FITPAR_FIXED << Constants::FITPAR_LIMITED << Constants::FITPAR_LOWERLIMITED
- << Constants::FITPAR_UPPERLIMITED << Constants::FITPAR_FREE;
- result.setValue(Constants::FITPAR_LIMITED);
+ result << "fixed" << "limited" << "lower limited"
+ << "upper limited" << "free";
+ result.setValue("limited");
result.setToolTips(tooltips);
return result;
}
@@ -49,7 +49,7 @@ const double range_factor = 0.5;
const QString FitParameterLinkItem::P_LINK = "Link";
const QString FitParameterLinkItem::P_DOMAIN = "Domain";
-FitParameterLinkItem::FitParameterLinkItem() : SessionItem(Constants::FitParameterLinkType)
+FitParameterLinkItem::FitParameterLinkItem() : SessionItem("FitParameterLink")
{
addProperty(P_LINK, "");
addProperty(P_DOMAIN, "");
@@ -63,13 +63,13 @@ const QString FitParameterItem::P_MIN = "Min";
const QString FitParameterItem::P_MAX = "Max";
const QString FitParameterItem::T_LINK = "Link tag";
-FitParameterItem::FitParameterItem() : SessionItem(Constants::FitParameterType)
+FitParameterItem::FitParameterItem() : SessionItem("FitParameter")
{
addProperty(P_TYPE, fitParameterTypeCombo().variant());
- addProperty(P_START_VALUE, 0.0)->setEditorType(Constants::ScientificSpinBoxType);
- addProperty(P_MIN, 0.0)->setEditorType(Constants::ScientificSpinBoxType);
- addProperty(P_MAX, 0.0)->setEditorType(Constants::ScientificSpinBoxType).setEnabled(false);
- registerTag(T_LINK, 0, -1, QStringList() << Constants::FitParameterLinkType);
+ addProperty(P_START_VALUE, 0.0)->setEditorType("ScientificSpinBox");
+ addProperty(P_MIN, 0.0)->setEditorType("ScientificSpinBox");
+ addProperty(P_MAX, 0.0)->setEditorType("ScientificSpinBox").setEnabled(false);
+ registerTag(T_LINK, 0, -1, QStringList() << "FitParameterLink");
setDefaultTag(T_LINK);
getItem(P_START_VALUE)->setLimits(RealLimits::limitless());
@@ -209,27 +209,27 @@ void FitParameterItem::setLimitEnabled(const QString& name, bool enabled)
bool FitParameterItem::isLimited() const
{
- return parameterType() == Constants::FITPAR_LIMITED;
+ return parameterType() == "limited";
}
bool FitParameterItem::isFree() const
{
- return parameterType() == Constants::FITPAR_FREE;
+ return parameterType() == "free";
}
bool FitParameterItem::isLowerLimited() const
{
- return parameterType() == Constants::FITPAR_LOWERLIMITED;
+ return parameterType() == "lower limited";
}
bool FitParameterItem::isUpperLimited() const
{
- return parameterType() == Constants::FITPAR_UPPERLIMITED;
+ return parameterType() == "upper limited";
}
bool FitParameterItem::isFixed() const
{
- return parameterType() == Constants::FITPAR_FIXED;
+ return parameterType() == "fixed";
}
// ----------------------------------------------------------------------------
@@ -237,9 +237,9 @@ bool FitParameterItem::isFixed() const
const QString FitParameterContainerItem::T_FIT_PARAMETERS = "Data tag";
FitParameterContainerItem::FitParameterContainerItem()
- : SessionItem(Constants::FitParameterContainerType)
+ : SessionItem("FitParameterContainer")
{
- registerTag(T_FIT_PARAMETERS, 0, -1, QStringList() << Constants::FitParameterType);
+ registerTag(T_FIT_PARAMETERS, 0, -1, QStringList() << "FitParameter");
setDefaultTag(T_FIT_PARAMETERS);
}
diff --git a/GUI/coregui/Models/FitParameterProxyModel.cpp b/GUI/coregui/Models/FitParameterProxyModel.cpp
index 4003ccc40319942b75cd013fc5abbbaeca0a8d36..44d2847482feb0aad9292933fee1dfbe620437b2 100644
--- a/GUI/coregui/Models/FitParameterProxyModel.cpp
+++ b/GUI/coregui/Models/FitParameterProxyModel.cpp
@@ -66,21 +66,21 @@ Qt::ItemFlags FitParameterProxyModel::flags(const QModelIndex& index) const
if (SessionItem* item = itemForIndex(index)) {
if (item->isEditable() && index.column() != 0)
returnVal |= Qt::ItemIsEditable;
- if (item->parent()->modelType() == Constants::FitParameterLinkType && index.column() == 0) {
+ if (item->parent()->modelType() == "FitParameterLink" && index.column() == 0) {
returnVal |= Qt::ItemIsDragEnabled;
}
const bool allow_one_fit_parameter_to_have_more_than_one_link = true;
if (allow_one_fit_parameter_to_have_more_than_one_link) {
// drop is allowed to fit parameter container, and, to FitParameterItem itself.
// (i.e. we can have more than one link in single FitParameterItem)
- if (item->modelType() == Constants::FitParameterType
- || item->modelType() == Constants::FitParameterContainerType) {
+ if (item->modelType() == "FitParameter"
+ || item->modelType() == "FitParameterContainer") {
returnVal |= Qt::ItemIsDropEnabled;
}
} else {
// drop is allowed only to fit parameter container
// (i.e. only one link is allowed in FitParameterItem)
- if (item->modelType() == Constants::FitParameterContainerType) {
+ if (item->modelType() == "FitParameterContainer") {
returnVal |= Qt::ItemIsDropEnabled;
}
}
@@ -97,7 +97,7 @@ QModelIndex FitParameterProxyModel::index(int row, int column, const QModelIndex
SessionItem* parent_item = itemForIndex(parent);
Q_ASSERT(parent_item);
- if (parent_item->modelType() == Constants::FitParameterContainerType) {
+ if (parent_item->modelType() == "FitParameterContainer") {
if (SessionItem* fitParItem = parent_item->childAt(row)) {
SessionItem* itemToPack = fitParItem;
if (column != 0) {
@@ -105,7 +105,7 @@ QModelIndex FitParameterProxyModel::index(int row, int column, const QModelIndex
}
return createIndex(row, column, itemToPack);
}
- } else if (parent_item->modelType() == Constants::FitParameterType && column == 0) {
+ } else if (parent_item->modelType() == "FitParameter" && column == 0) {
QVector<SessionItem*> links = parent_item->getItems(FitParameterItem::T_LINK);
if (row < links.size()) {
if (SessionItem* linkItem = links.at(row)) {
@@ -128,7 +128,7 @@ QModelIndex FitParameterProxyModel::parent(const QModelIndex& child) const
if (SessionItem* parent_item = child_item->parent()) {
if (!isValidSourceItem(parent_item))
return QModelIndex();
- if (parent_item->modelType() == Constants::FitParameterLinkType) {
+ if (parent_item->modelType() == "FitParameterLink") {
SessionItem* fitPar = parent_item->parent();
if (!isValidSourceItem(fitPar))
return QModelIndex();
@@ -151,9 +151,9 @@ int FitParameterProxyModel::rowCount(const QModelIndex& parent) const
if (parent_item != m_root_item && !isValidSourceItem(parent_item))
return 0;
- if (parent_item->modelType() == Constants::FitParameterContainerType) {
+ if (parent_item->modelType() == "FitParameterContainer") {
return parent_item->numberOfChildren();
- } else if (parent_item->modelType() == Constants::FitParameterType) {
+ } else if (parent_item->modelType() == "FitParameter") {
return parent_item->getItems(FitParameterItem::T_LINK).size();
}
return 0;
@@ -172,7 +172,7 @@ int FitParameterProxyModel::columnCount(const QModelIndex& parent) const
if (parent.isValid()) {
if (SessionItem* parentItem = itemForIndex(parent)) {
- if (parentItem->modelType() == Constants::FitParameterType) {
+ if (parentItem->modelType() == "FitParameter") {
return (parentItem->getItems(FitParameterItem::T_LINK).size() ? 1 : 0);
}
}
@@ -190,7 +190,7 @@ QVariant FitParameterProxyModel::data(const QModelIndex& index, int role) const
if (SessionItem* item = itemForIndex(index)) {
if (role == Qt::DisplayRole || role == Qt::EditRole) {
- if (item->modelType() == Constants::FitParameterType) {
+ if (item->modelType() == "FitParameter") {
return item->displayName();
} else {
return item->value();
@@ -264,7 +264,7 @@ bool FitParameterProxyModel::dropMimeData(const QMimeData* data, Qt::DropAction
if (parent.isValid()) {
if (SessionItem* fitParItem = itemForIndex(parent)) {
- Q_ASSERT(fitParItem->modelType() == Constants::FitParameterType);
+ Q_ASSERT(fitParItem->modelType() == "FitParameter");
ParameterItem* parItem = FitParameterHelper::getParameterItem(
m_root_item, QString::fromLatin1(data->data(SessionXML::LinkMimeType)));
Q_ASSERT(parItem);
@@ -355,18 +355,18 @@ QModelIndex FitParameterProxyModel::indexOfItem(SessionItem* item) const
return QModelIndex();
if (SessionItem* parent_item = item->parent()) {
- if (parent_item->modelType() == Constants::FitParameterContainerType) {
- if (item->modelType() == Constants::FitParameterType) {
+ if (parent_item->modelType() == "FitParameterContainer") {
+ if (item->modelType() == "FitParameter") {
return createIndex(ParentRow(*item), 0, item);
}
- } else if (parent_item->modelType() == Constants::FitParameterType) {
+ } else if (parent_item->modelType() == "FitParameter") {
QString tag = parent_item->tagFromItem(item);
int col = m_columnNames.key(tag, -1);
if (col > 0) {
return createIndex(ParentRow(*parent_item), col, item);
}
- } else if (parent_item->modelType() == Constants::FitParameterLinkType) {
+ } else if (parent_item->modelType() == "FitParameterLink") {
QVector<SessionItem*> links = parent_item->parent()->getItems(FitParameterItem::T_LINK);
return createIndex(links.indexOf(parent_item), 0, item);
}
diff --git a/GUI/coregui/Models/FitSuiteItem.cpp b/GUI/coregui/Models/FitSuiteItem.cpp
index a65d149980003ee424443f3274a369c22aaf9ff5..878d2c1751431ddf71c22045ea38009a93c5c14d 100644
--- a/GUI/coregui/Models/FitSuiteItem.cpp
+++ b/GUI/coregui/Models/FitSuiteItem.cpp
@@ -22,14 +22,14 @@ const QString FitSuiteItem::P_CHI2 = "Chi2";
const QString FitSuiteItem::T_FIT_PARAMETERS = "Fit parameters container";
const QString FitSuiteItem::T_MINIMIZER = "Minimizer settings";
-FitSuiteItem::FitSuiteItem() : SessionItem(Constants::FitSuiteType)
+FitSuiteItem::FitSuiteItem() : SessionItem("FitSuite")
{
addProperty(P_UPDATE_INTERVAL, 10);
addProperty(P_ITERATION_COUNT, 0);
addProperty(P_CHI2, 0.0);
- registerTag(T_FIT_PARAMETERS, 1, 1, QStringList() << Constants::FitParameterContainerType);
- registerTag(T_MINIMIZER, 1, 1, QStringList() << Constants::MinimizerContainerType);
+ registerTag(T_FIT_PARAMETERS, 1, 1, QStringList() << "FitParameterContainer");
+ registerTag(T_MINIMIZER, 1, 1, QStringList() << "MinimizerContainer");
}
FitParameterContainerItem* FitSuiteItem::fitParameterContainerItem()
diff --git a/GUI/coregui/Models/FootprintItems.cpp b/GUI/coregui/Models/FootprintItems.cpp
index e04c68db3ec0628a874d82b1f5a10ecbc3979e4f..b9b992c69a3acb6bf41f57ec2ccdc50baa2463d3 100644
--- a/GUI/coregui/Models/FootprintItems.cpp
+++ b/GUI/coregui/Models/FootprintItems.cpp
@@ -15,7 +15,6 @@
#include "GUI/coregui/Models/FootprintItems.h"
#include "Core/Beam/FootprintFactorGaussian.h"
#include "Core/Beam/FootprintFactorSquare.h"
-#include "GUI/coregui/Models/item_constants.h"
namespace
{
@@ -33,7 +32,7 @@ FootprintItem::~FootprintItem() = default;
// Footprint none
/* ------------------------------------------------ */
-FootprintNoneItem::FootprintNoneItem() : FootprintItem(Constants::FootprintNoneType) {}
+FootprintNoneItem::FootprintNoneItem() : FootprintItem("NoFootprint") {}
FootprintNoneItem::~FootprintNoneItem() = default;
@@ -47,7 +46,7 @@ std::unique_ptr<IFootprintFactor> FootprintNoneItem::createFootprint() const
const QString FootprintGaussianItem::P_VALUE = footprint_value_name;
-FootprintGaussianItem::FootprintGaussianItem() : FootprintItem(Constants::FootprintGaussianType)
+FootprintGaussianItem::FootprintGaussianItem() : FootprintItem("GaussianFootrpint")
{
addProperty(P_VALUE, 0.0)
->setLimits(RealLimits::nonnegative())
@@ -66,7 +65,7 @@ std::unique_ptr<IFootprintFactor> FootprintGaussianItem::createFootprint() const
const QString FootprintSquareItem::P_VALUE = footprint_value_name;
-FootprintSquareItem::FootprintSquareItem() : FootprintItem(Constants::FootprintSquareType)
+FootprintSquareItem::FootprintSquareItem() : FootprintItem("SquareFootprint")
{
addProperty(P_VALUE, 0.0)
->setLimits(RealLimits::nonnegative())
diff --git a/GUI/coregui/Models/FormFactorItems.cpp b/GUI/coregui/Models/FormFactorItems.cpp
index 97016cc56a7606ce39eae3306893bd59739b12e9..2a50ab966c7715a0ca0f1b37b0218e476f998cec 100644
--- a/GUI/coregui/Models/FormFactorItems.cpp
+++ b/GUI/coregui/Models/FormFactorItems.cpp
@@ -23,7 +23,7 @@ const QString AnisoPyramidItem::P_WIDTH = QString::fromStdString("Width");
const QString AnisoPyramidItem::P_HEIGHT = QString::fromStdString("Height");
const QString AnisoPyramidItem::P_ALPHA = QString::fromStdString("Alpha");
-AnisoPyramidItem::AnisoPyramidItem() : FormFactorItem(Constants::AnisoPyramidType)
+AnisoPyramidItem::AnisoPyramidItem() : FormFactorItem("AnisoPyramid")
{
setToolTip(QStringLiteral("A truncated pyramid with a rectangular base"));
addProperty(P_LENGTH, 20.0)
@@ -48,7 +48,7 @@ const QString BarGaussItem::P_LENGTH = QString::fromStdString("Length");
const QString BarGaussItem::P_WIDTH = QString::fromStdString("Width");
const QString BarGaussItem::P_HEIGHT = QString::fromStdString("Height");
-BarGaussItem::BarGaussItem() : FormFactorItem(Constants::BarGaussType)
+BarGaussItem::BarGaussItem() : FormFactorItem("BarGauss")
{
setToolTip(QStringLiteral("Rectangular cuboid"));
addProperty(P_LENGTH, 20.0)->setToolTip(QStringLiteral("Length of the base in nanometers"));
@@ -69,7 +69,7 @@ const QString BarLorentzItem::P_LENGTH = QString::fromStdString("Length");
const QString BarLorentzItem::P_WIDTH = QString::fromStdString("Width");
const QString BarLorentzItem::P_HEIGHT = QString::fromStdString("Height");
-BarLorentzItem::BarLorentzItem() : FormFactorItem(Constants::BarLorentzType)
+BarLorentzItem::BarLorentzItem() : FormFactorItem("BarLorentz")
{
setToolTip(QStringLiteral("Rectangular cuboid"));
addProperty(P_LENGTH, 20.0)->setToolTip(QStringLiteral("Length of the base in nanometers"));
@@ -90,7 +90,7 @@ const QString BoxItem::P_LENGTH = QString::fromStdString("Length");
const QString BoxItem::P_WIDTH = QString::fromStdString("Width");
const QString BoxItem::P_HEIGHT = QString::fromStdString("Height");
-BoxItem::BoxItem() : FormFactorItem(Constants::BoxType)
+BoxItem::BoxItem() : FormFactorItem("Box")
{
setToolTip(QStringLiteral("Rectangular cuboid"));
addProperty(P_LENGTH, 20.0)->setToolTip(QStringLiteral("Length of the base in nanometers"));
@@ -111,7 +111,7 @@ const QString ConeItem::P_RADIUS = QString::fromStdString("Radius");
const QString ConeItem::P_HEIGHT = QString::fromStdString("Height");
const QString ConeItem::P_ALPHA = QString::fromStdString("Alpha");
-ConeItem::ConeItem() : FormFactorItem(Constants::ConeType)
+ConeItem::ConeItem() : FormFactorItem("Cone")
{
setToolTip(QStringLiteral("Truncated cone with circular base"));
addProperty(P_RADIUS, 10.0)->setToolTip(QStringLiteral("Radius of the base in nanometers"));
@@ -133,7 +133,7 @@ const QString Cone6Item::P_BASEEDGE = QString::fromStdString("BaseEdge");
const QString Cone6Item::P_HEIGHT = QString::fromStdString("Height");
const QString Cone6Item::P_ALPHA = QString::fromStdString("Alpha");
-Cone6Item::Cone6Item() : FormFactorItem(Constants::Cone6Type)
+Cone6Item::Cone6Item() : FormFactorItem("Cone6")
{
setToolTip(QStringLiteral("A truncated pyramid, based on a regular hexagon"));
addProperty(P_BASEEDGE, 10.0)
@@ -158,7 +158,7 @@ const QString CuboctahedronItem::P_HEIGHT = QString::fromStdString("Height");
const QString CuboctahedronItem::P_HEIGHT_RATIO = QString::fromStdString("HeightRatio");
const QString CuboctahedronItem::P_ALPHA = QString::fromStdString("Alpha");
-CuboctahedronItem::CuboctahedronItem() : FormFactorItem(Constants::CuboctahedronType)
+CuboctahedronItem::CuboctahedronItem() : FormFactorItem("Cuboctahedron")
{
setToolTip(QStringLiteral("Compound of two truncated pyramids with a common square base \n"
"and opposite orientations"));
@@ -185,7 +185,7 @@ std::unique_ptr<IFormFactor> CuboctahedronItem::createFormFactor() const
const QString CylinderItem::P_RADIUS = QString::fromStdString("Radius");
const QString CylinderItem::P_HEIGHT = QString::fromStdString("Height");
-CylinderItem::CylinderItem() : FormFactorItem(Constants::CylinderType)
+CylinderItem::CylinderItem() : FormFactorItem("Cylinder")
{
setToolTip(QStringLiteral("Cylinder with a circular base"));
addProperty(P_RADIUS, 8.0)
@@ -203,7 +203,7 @@ std::unique_ptr<IFormFactor> CylinderItem::createFormFactor() const
const QString DodecahedronItem::P_EDGE = QString::fromStdString("Edge");
-DodecahedronItem::DodecahedronItem() : FormFactorItem(Constants::DodecahedronType)
+DodecahedronItem::DodecahedronItem() : FormFactorItem("Dodecahedron")
{
setToolTip(QStringLiteral("Dodecahedron"));
addProperty(P_EDGE, 10.0)->setToolTip(QStringLiteral("Length of the edge in nanometers"));
@@ -218,7 +218,7 @@ std::unique_ptr<IFormFactor> DodecahedronItem::createFormFactor() const
const QString DotItem::P_RADIUS = QString::fromStdString("Radius");
-DotItem::DotItem() : FormFactorItem(Constants::DotType)
+DotItem::DotItem() : FormFactorItem("Dot")
{
setToolTip(QStringLiteral("A dot, with constant formfactor F(q)=4pi/3 R^3"));
addProperty(P_RADIUS, 8.0)
@@ -237,7 +237,7 @@ const QString EllipsoidalCylinderItem::P_RADIUS_Y = QString::fromStdString("Radi
const QString EllipsoidalCylinderItem::P_HEIGHT = QString::fromStdString("Height");
EllipsoidalCylinderItem::EllipsoidalCylinderItem()
- : FormFactorItem(Constants::EllipsoidalCylinderType)
+ : FormFactorItem("EllipsoidalCylinder")
{
setToolTip(QStringLiteral("Cylinder with an ellipse cross section"));
addProperty(P_RADIUS_X, 8.0)
@@ -261,7 +261,7 @@ std::unique_ptr<IFormFactor> EllipsoidalCylinderItem::createFormFactor() const
const QString FullSphereItem::P_RADIUS = QString::fromStdString("Radius");
-FullSphereItem::FullSphereItem() : FormFactorItem(Constants::FullSphereType)
+FullSphereItem::FullSphereItem() : FormFactorItem("FullSphere")
{
setToolTip(QStringLiteral("Full sphere"));
addProperty(P_RADIUS, 8.0)->setToolTip(QStringLiteral("Radius of the sphere in nanometers"));
@@ -277,7 +277,7 @@ std::unique_ptr<IFormFactor> FullSphereItem::createFormFactor() const
const QString FullSpheroidItem::P_RADIUS = QString::fromStdString("Radius");
const QString FullSpheroidItem::P_HEIGHT = QString::fromStdString("Height");
-FullSpheroidItem::FullSpheroidItem() : FormFactorItem(Constants::FullSpheroidType)
+FullSpheroidItem::FullSpheroidItem() : FormFactorItem("FullSpheroid")
{
setToolTip(
QStringLiteral("Full spheroid, generated by rotating an ellipse around the vertical axis"));
@@ -299,7 +299,7 @@ const QString HemiEllipsoidItem::P_RADIUS_X = QString::fromStdString("RadiusX");
const QString HemiEllipsoidItem::P_RADIUS_Y = QString::fromStdString("RadiusY");
const QString HemiEllipsoidItem::P_HEIGHT = QString::fromStdString("Height");
-HemiEllipsoidItem::HemiEllipsoidItem() : FormFactorItem(Constants::HemiEllipsoidType)
+HemiEllipsoidItem::HemiEllipsoidItem() : FormFactorItem("HemiEllipsoid")
{
setToolTip(
QStringLiteral("An horizontally oriented ellipsoid, truncated at the central plane"));
@@ -324,7 +324,7 @@ std::unique_ptr<IFormFactor> HemiEllipsoidItem::createFormFactor() const
const QString IcosahedronItem::P_EDGE = QString::fromStdString("Edge");
-IcosahedronItem::IcosahedronItem() : FormFactorItem(Constants::IcosahedronType)
+IcosahedronItem::IcosahedronItem() : FormFactorItem("Icosahedron")
{
setToolTip(QStringLiteral("Icosahedron"));
addProperty(P_EDGE, 10.0)->setToolTip(QStringLiteral("Length of the edge in nanometers"));
@@ -340,7 +340,7 @@ std::unique_ptr<IFormFactor> IcosahedronItem::createFormFactor() const
const QString Prism3Item::P_BASEEDGE = QString::fromStdString("BaseEdge");
const QString Prism3Item::P_HEIGHT = QString::fromStdString("Height");
-Prism3Item::Prism3Item() : FormFactorItem(Constants::Prism3Type)
+Prism3Item::Prism3Item() : FormFactorItem("Prism3")
{
setToolTip(QStringLiteral("Prism with an equilaterial triangle base"));
addProperty(P_BASEEDGE, 10.0)
@@ -359,7 +359,7 @@ std::unique_ptr<IFormFactor> Prism3Item::createFormFactor() const
const QString Prism6Item::P_BASEEDGE = QString::fromStdString("BaseEdge");
const QString Prism6Item::P_HEIGHT = QString::fromStdString("Height");
-Prism6Item::Prism6Item() : FormFactorItem(Constants::Prism6Type)
+Prism6Item::Prism6Item() : FormFactorItem("Prism6")
{
setToolTip(QStringLiteral("Prism with a regular hexagonal base"));
addProperty(P_BASEEDGE, 5.0)
@@ -379,7 +379,7 @@ const QString PyramidItem::P_BASEEDGE = QString::fromStdString("BaseEdge");
const QString PyramidItem::P_HEIGHT = QString::fromStdString("Height");
const QString PyramidItem::P_ALPHA = QString::fromStdString("Alpha");
-PyramidItem::PyramidItem() : FormFactorItem(Constants::PyramidType)
+PyramidItem::PyramidItem() : FormFactorItem("Pyramid")
{
setToolTip(QStringLiteral("Truncated pyramid with a square base"));
addProperty(P_BASEEDGE, 18.0)
@@ -402,7 +402,7 @@ const QString Ripple1BoxItem::P_LENGTH = QString::fromStdString("Length");
const QString Ripple1BoxItem::P_WIDTH = QString::fromStdString("Width");
const QString Ripple1BoxItem::P_HEIGHT = QString::fromStdString("Height");
-Ripple1BoxItem::Ripple1BoxItem() : FormFactorItem(Constants::Ripple1BoxType)
+Ripple1BoxItem::Ripple1BoxItem() : FormFactorItem("Ripple1Box")
{
setToolTip(QStringLiteral("Particle with a cosine profile and a rectangular base"));
addProperty(P_LENGTH, 27.0)
@@ -425,7 +425,7 @@ const QString Ripple1GaussItem::P_LENGTH = QString::fromStdString("Length");
const QString Ripple1GaussItem::P_WIDTH = QString::fromStdString("Width");
const QString Ripple1GaussItem::P_HEIGHT = QString::fromStdString("Height");
-Ripple1GaussItem::Ripple1GaussItem() : FormFactorItem(Constants::Ripple1GaussType)
+Ripple1GaussItem::Ripple1GaussItem() : FormFactorItem("Ripple1Gauss")
{
setToolTip(QStringLiteral("Particle with a cosine profile and a rectangular base"));
addProperty(P_LENGTH, 27.0)
@@ -448,7 +448,7 @@ const QString Ripple1LorentzItem::P_LENGTH = QString::fromStdString("Length");
const QString Ripple1LorentzItem::P_WIDTH = QString::fromStdString("Width");
const QString Ripple1LorentzItem::P_HEIGHT = QString::fromStdString("Height");
-Ripple1LorentzItem::Ripple1LorentzItem() : FormFactorItem(Constants::Ripple1LorentzType)
+Ripple1LorentzItem::Ripple1LorentzItem() : FormFactorItem("Ripple1Lorentz")
{
setToolTip(QStringLiteral("Particle with a cosine profile and a rectangular base"));
addProperty(P_LENGTH, 27.0)
@@ -472,7 +472,7 @@ const QString Ripple2BoxItem::P_WIDTH = QString::fromStdString("Width");
const QString Ripple2BoxItem::P_HEIGHT = QString::fromStdString("Height");
const QString Ripple2BoxItem::P_ASYMMETRY = QString::fromStdString("AsymmetryLength");
-Ripple2BoxItem::Ripple2BoxItem() : FormFactorItem(Constants::Ripple2BoxType)
+Ripple2BoxItem::Ripple2BoxItem() : FormFactorItem("Ripple2Box")
{
setToolTip(
QStringLiteral("Particle with an asymmetric triangle profile and a rectangular base"));
@@ -499,7 +499,7 @@ const QString Ripple2GaussItem::P_WIDTH = QString::fromStdString("Width");
const QString Ripple2GaussItem::P_HEIGHT = QString::fromStdString("Height");
const QString Ripple2GaussItem::P_ASYMMETRY = QString::fromStdString("AsymmetryLength");
-Ripple2GaussItem::Ripple2GaussItem() : FormFactorItem(Constants::Ripple2GaussType)
+Ripple2GaussItem::Ripple2GaussItem() : FormFactorItem("Ripple2Gauss")
{
setToolTip(
QStringLiteral("Particle with an asymmetric triangle profile and a rectangular base"));
@@ -526,7 +526,7 @@ const QString Ripple2LorentzItem::P_WIDTH = QString::fromStdString("Width");
const QString Ripple2LorentzItem::P_HEIGHT = QString::fromStdString("Height");
const QString Ripple2LorentzItem::P_ASYMMETRY = QString::fromStdString("AsymmetryLength");
-Ripple2LorentzItem::Ripple2LorentzItem() : FormFactorItem(Constants::Ripple2LorentzType)
+Ripple2LorentzItem::Ripple2LorentzItem() : FormFactorItem("Ripple2Lorentz")
{
setToolTip(
QStringLiteral("Particle with an asymmetric triangle profile and a rectangular base"));
@@ -552,7 +552,7 @@ const QString TetrahedronItem::P_BASEEDGE = QString::fromStdString("BaseEdge");
const QString TetrahedronItem::P_HEIGHT = QString::fromStdString("Height");
const QString TetrahedronItem::P_ALPHA = QString::fromStdString("Alpha");
-TetrahedronItem::TetrahedronItem() : FormFactorItem(Constants::TetrahedronType)
+TetrahedronItem::TetrahedronItem() : FormFactorItem("Tetrahedron")
{
setToolTip(QStringLiteral("A truncated tethrahedron"));
addProperty(P_BASEEDGE, 15.0)
@@ -576,7 +576,7 @@ std::unique_ptr<IFormFactor> TetrahedronItem::createFormFactor() const
const QString TruncatedCubeItem::P_LENGTH = QString::fromStdString("Length");
const QString TruncatedCubeItem::P_REMOVED_LENGTH = QString::fromStdString("RemovedLength");
-TruncatedCubeItem::TruncatedCubeItem() : FormFactorItem(Constants::TruncatedCubeType)
+TruncatedCubeItem::TruncatedCubeItem() : FormFactorItem("TruncatedCube")
{
setToolTip(QStringLiteral("A cube whose eight vertices have been removed"));
addProperty(P_LENGTH, 15.0)
@@ -597,7 +597,7 @@ const QString TruncatedSphereItem::P_RADIUS = QString::fromStdString("Radius");
const QString TruncatedSphereItem::P_HEIGHT = QString::fromStdString("Height");
const QString TruncatedSphereItem::P_REMOVED_TOP = QString::fromStdString("DeltaHeight");
-TruncatedSphereItem::TruncatedSphereItem() : FormFactorItem(Constants::TruncatedSphereType)
+TruncatedSphereItem::TruncatedSphereItem() : FormFactorItem("TruncatedSphere")
{
setToolTip(QStringLiteral("Spherical dome"));
addProperty(P_RADIUS, 5.0)
@@ -622,7 +622,7 @@ const QString TruncatedSpheroidItem::P_HEIGHT = QString::fromStdString("Height")
const QString TruncatedSpheroidItem::P_HFC = QString::fromStdString("HeightFlattening");
const QString TruncatedSpheroidItem::P_REMOVED_TOP = QString::fromStdString("DeltaHeight");
-TruncatedSpheroidItem::TruncatedSpheroidItem() : FormFactorItem(Constants::TruncatedSpheroidType)
+TruncatedSpheroidItem::TruncatedSpheroidItem() : FormFactorItem("TruncatedSpheroid")
{
setToolTip(QStringLiteral("Spheroidal dome"));
addProperty(P_RADIUS, 7.5)
diff --git a/GUI/coregui/Models/GUIDomainSampleVisitor.cpp b/GUI/coregui/Models/GUIDomainSampleVisitor.cpp
index da06bcc4e9f796aa4016c2676f56d5f588c67f7d..23615b7f1aca4063cebfafe74e3099f7cf5beddb 100644
--- a/GUI/coregui/Models/GUIDomainSampleVisitor.cpp
+++ b/GUI/coregui/Models/GUIDomainSampleVisitor.cpp
@@ -82,10 +82,10 @@ void GUIDomainSampleVisitor::visit(const ParticleLayout* p_sample)
SessionItem* p_parent = m_levelToParentItem[depth() - 1];
SessionItem* p_layout_item(nullptr);
if (p_parent) {
- p_layout_item = m_sampleModel->insertNewItem(Constants::ParticleLayoutType,
+ p_layout_item = m_sampleModel->insertNewItem("ParticleLayout",
m_sampleModel->indexOfItem(p_parent));
} else {
- p_layout_item = m_sampleModel->insertNewItem(Constants::ParticleLayoutType);
+ p_layout_item = m_sampleModel->insertNewItem("ParticleLayout");
}
p_layout_item->setItemValue(ParticleLayoutItem::P_TOTAL_DENSITY,
p_sample->totalParticleSurfaceDensity());
@@ -105,7 +105,7 @@ void GUIDomainSampleVisitor::visit(const Layer* p_sample)
MultiLayerUtils::LayerTopInterface(*p_multilayer, layer_index);
SessionItem* p_layer_item =
- m_sampleModel->insertNewItem(Constants::LayerType, m_sampleModel->indexOfItem(p_parent));
+ m_sampleModel->insertNewItem("Layer", m_sampleModel->indexOfItem(p_parent));
p_layer_item->setItemValue(LayerItem::P_MATERIAL,
createMaterialFromDomain(p_sample->material()).variant());
@@ -116,7 +116,7 @@ void GUIDomainSampleVisitor::visit(const Layer* p_sample)
void GUIDomainSampleVisitor::visit(const MultiLayer* p_sample)
{
- SessionItem* p_multilayer_item = m_sampleModel->insertNewItem(Constants::MultiLayerType);
+ SessionItem* p_multilayer_item = m_sampleModel->insertNewItem("MultiLayer");
p_multilayer_item->setItemName(p_sample->getName().c_str());
p_multilayer_item->setItemValue(MultiLayerItem::P_CROSS_CORR_LENGTH,
p_sample->crossCorrLength());
@@ -127,7 +127,7 @@ void GUIDomainSampleVisitor::visit(const MultiLayer* p_sample)
void GUIDomainSampleVisitor::visit(const Particle* p_sample)
{
- auto p_particle_item = InsertIParticle(p_sample, Constants::ParticleType);
+ auto p_particle_item = InsertIParticle(p_sample, "Particle");
p_particle_item->setItemValue(ParticleItem::P_MATERIAL,
createMaterialFromDomain(p_sample->material()).variant());
}
@@ -137,7 +137,7 @@ void GUIDomainSampleVisitor::visit(const ParticleDistribution* p_sample)
SessionItem* p_layout_item = m_levelToParentItem[depth() - 1];
Q_ASSERT(p_layout_item);
SessionItem* p_particle_distribution_item = m_sampleModel->insertNewItem(
- Constants::ParticleDistributionType, m_sampleModel->indexOfItem(p_layout_item));
+ "ParticleDistribution", m_sampleModel->indexOfItem(p_layout_item));
Q_ASSERT(p_particle_distribution_item);
TransformFromDomain::setParticleDistributionItem(p_particle_distribution_item, *p_sample);
@@ -148,24 +148,24 @@ void GUIDomainSampleVisitor::visit(const ParticleDistribution* p_sample)
void GUIDomainSampleVisitor::visit(const ParticleCoreShell* p_sample)
{
- InsertIParticle(p_sample, Constants::ParticleCoreShellType);
+ InsertIParticle(p_sample, "ParticleCoreShell");
}
void GUIDomainSampleVisitor::visit(const ParticleComposition* p_sample)
{
- InsertIParticle(p_sample, Constants::ParticleCompositionType);
+ InsertIParticle(p_sample, "ParticleComposition");
}
void GUIDomainSampleVisitor::visit(const MesoCrystal* p_sample)
{
- InsertIParticle(p_sample, Constants::MesoCrystalType);
+ InsertIParticle(p_sample, "MesoCrystal");
}
void GUIDomainSampleVisitor::visit(const Crystal* p_sample)
{
SessionItem* p_mesocrystal_item = m_levelToParentItem[depth() - 1];
Q_ASSERT(p_mesocrystal_item);
- if (p_mesocrystal_item->modelType() != Constants::MesoCrystalType) {
+ if (p_mesocrystal_item->modelType() != "MesoCrystal") {
throw GUIHelpers::Error("GUIObjectBuilder::visit(const Crystal*) "
"-> Error. Parent is not a MesoCrystal");
}
@@ -185,7 +185,7 @@ void GUIDomainSampleVisitor::visit(const Crystal* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorAnisoPyramid* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::AnisoPyramidType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "AnisoPyramid");
p_ff_item->setItemValue(AnisoPyramidItem::P_LENGTH, p_sample->getLength());
p_ff_item->setItemValue(AnisoPyramidItem::P_WIDTH, p_sample->getWidth());
p_ff_item->setItemValue(AnisoPyramidItem::P_HEIGHT, p_sample->getHeight());
@@ -196,7 +196,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorAnisoPyramid* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorBarGauss* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::BarGaussType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "BarGauss");
p_ff_item->setItemValue(BarGaussItem::P_LENGTH, p_sample->getLength());
p_ff_item->setItemValue(BarGaussItem::P_WIDTH, p_sample->getWidth());
p_ff_item->setItemValue(BarGaussItem::P_HEIGHT, p_sample->getHeight());
@@ -206,7 +206,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorBarGauss* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorBarLorentz* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::BarLorentzType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "BarLorentz");
p_ff_item->setItemValue(BarLorentzItem::P_LENGTH, p_sample->getLength());
p_ff_item->setItemValue(BarLorentzItem::P_WIDTH, p_sample->getWidth());
p_ff_item->setItemValue(BarLorentzItem::P_HEIGHT, p_sample->getHeight());
@@ -216,7 +216,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorBarLorentz* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorBox* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::BoxType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Box");
p_ff_item->setItemValue(BoxItem::P_LENGTH, p_sample->getLength());
p_ff_item->setItemValue(BoxItem::P_WIDTH, p_sample->getWidth());
p_ff_item->setItemValue(BoxItem::P_HEIGHT, p_sample->getHeight());
@@ -226,7 +226,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorBox* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorCone* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::ConeType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Cone");
p_ff_item->setItemValue(ConeItem::P_RADIUS, p_sample->getRadius());
p_ff_item->setItemValue(ConeItem::P_HEIGHT, p_sample->getHeight());
p_ff_item->setItemValue(ConeItem::P_ALPHA, Units::rad2deg(p_sample->getAlpha()));
@@ -236,7 +236,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorCone* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorCone6* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::Cone6Type);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Cone6");
p_ff_item->setItemValue(Cone6Item::P_BASEEDGE, p_sample->getBaseEdge());
p_ff_item->setItemValue(Cone6Item::P_HEIGHT, p_sample->getHeight());
p_ff_item->setItemValue(Cone6Item::P_ALPHA, Units::rad2deg(p_sample->getAlpha()));
@@ -246,7 +246,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorCone6* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorCuboctahedron* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::CuboctahedronType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Cuboctahedron");
p_ff_item->setItemValue(CuboctahedronItem::P_LENGTH, p_sample->getLength());
p_ff_item->setItemValue(CuboctahedronItem::P_HEIGHT, p_sample->getHeight());
p_ff_item->setItemValue(CuboctahedronItem::P_HEIGHT_RATIO, p_sample->getHeightRatio());
@@ -257,7 +257,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorCuboctahedron* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorCylinder* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::CylinderType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Cylinder");
p_ff_item->setItemValue(CylinderItem::P_RADIUS, p_sample->getRadius());
p_ff_item->setItemValue(CylinderItem::P_HEIGHT, p_sample->getHeight());
m_levelToParentItem[depth()] = p_particle_item;
@@ -266,7 +266,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorCylinder* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorDodecahedron* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::DodecahedronType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Dodecahedron");
p_ff_item->setItemValue(DodecahedronItem::P_EDGE, p_sample->getEdge());
m_levelToParentItem[depth()] = p_particle_item;
}
@@ -274,7 +274,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorDodecahedron* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorDot* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::DotType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Dot");
p_ff_item->setItemValue(FullSphereItem::P_RADIUS, p_sample->getRadius());
m_levelToParentItem[depth()] = p_particle_item;
}
@@ -282,7 +282,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorDot* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorEllipsoidalCylinder* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::EllipsoidalCylinderType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "EllipsoidalCylinder");
p_ff_item->setItemValue(EllipsoidalCylinderItem::P_RADIUS_X, p_sample->getRadiusX());
p_ff_item->setItemValue(EllipsoidalCylinderItem::P_RADIUS_Y, p_sample->getRadiusY());
p_ff_item->setItemValue(EllipsoidalCylinderItem::P_HEIGHT, p_sample->getHeight());
@@ -292,7 +292,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorEllipsoidalCylinder* p_sample
void GUIDomainSampleVisitor::visit(const FormFactorFullSphere* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::FullSphereType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "FullSphere");
p_ff_item->setItemValue(FullSphereItem::P_RADIUS, p_sample->getRadius());
m_levelToParentItem[depth()] = p_particle_item;
}
@@ -300,7 +300,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorFullSphere* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorFullSpheroid* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::FullSpheroidType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "FullSpheroid");
p_ff_item->setItemValue(FullSpheroidItem::P_RADIUS, p_sample->getRadius());
p_ff_item->setItemValue(FullSpheroidItem::P_HEIGHT, p_sample->getHeight());
m_levelToParentItem[depth()] = p_particle_item;
@@ -309,7 +309,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorFullSpheroid* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorIcosahedron* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::IcosahedronType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Icosahedron");
p_ff_item->setItemValue(IcosahedronItem::P_EDGE, p_sample->getEdge());
m_levelToParentItem[depth()] = p_particle_item;
}
@@ -317,7 +317,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorIcosahedron* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorHemiEllipsoid* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::HemiEllipsoidType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "HemiEllipsoid");
p_ff_item->setItemValue(HemiEllipsoidItem::P_RADIUS_X, p_sample->getRadiusX());
p_ff_item->setItemValue(HemiEllipsoidItem::P_RADIUS_Y, p_sample->getRadiusY());
p_ff_item->setItemValue(HemiEllipsoidItem::P_HEIGHT, p_sample->getHeight());
@@ -327,7 +327,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorHemiEllipsoid* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorPrism3* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::Prism3Type);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Prism3");
p_ff_item->setItemValue(Prism3Item::P_BASEEDGE, p_sample->getBaseEdge());
p_ff_item->setItemValue(Prism3Item::P_HEIGHT, p_sample->getHeight());
m_levelToParentItem[depth()] = p_particle_item;
@@ -336,7 +336,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorPrism3* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorPrism6* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::Prism6Type);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Prism6");
p_ff_item->setItemValue(Prism6Item::P_BASEEDGE, p_sample->getBaseEdge());
p_ff_item->setItemValue(Prism6Item::P_HEIGHT, p_sample->getHeight());
m_levelToParentItem[depth()] = p_particle_item;
@@ -345,7 +345,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorPrism6* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorPyramid* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::PyramidType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Pyramid");
p_ff_item->setItemValue(PyramidItem::P_BASEEDGE, p_sample->getBaseEdge());
p_ff_item->setItemValue(PyramidItem::P_HEIGHT, p_sample->getHeight());
p_ff_item->setItemValue(PyramidItem::P_ALPHA, Units::rad2deg(p_sample->getAlpha()));
@@ -355,7 +355,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorPyramid* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorRipple1Box* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::Ripple1BoxType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Ripple1Box");
p_ff_item->setItemValue(Ripple1BoxItem::P_LENGTH, p_sample->getLength());
p_ff_item->setItemValue(Ripple1BoxItem::P_WIDTH, p_sample->getWidth());
p_ff_item->setItemValue(Ripple1BoxItem::P_HEIGHT, p_sample->getHeight());
@@ -365,7 +365,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorRipple1Box* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorRipple1Gauss* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::Ripple1GaussType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Ripple1Gauss");
p_ff_item->setItemValue(Ripple1GaussItem::P_LENGTH, p_sample->getLength());
p_ff_item->setItemValue(Ripple1GaussItem::P_WIDTH, p_sample->getWidth());
p_ff_item->setItemValue(Ripple1GaussItem::P_HEIGHT, p_sample->getHeight());
@@ -375,7 +375,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorRipple1Gauss* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorRipple1Lorentz* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::Ripple1LorentzType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Ripple1Lorentz");
p_ff_item->setItemValue(Ripple1LorentzItem::P_LENGTH, p_sample->getLength());
p_ff_item->setItemValue(Ripple1LorentzItem::P_WIDTH, p_sample->getWidth());
p_ff_item->setItemValue(Ripple1LorentzItem::P_HEIGHT, p_sample->getHeight());
@@ -385,7 +385,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorRipple1Lorentz* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorRipple2Box* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::Ripple2BoxType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Ripple2Box");
p_ff_item->setItemValue(Ripple2BoxItem::P_LENGTH, p_sample->getLength());
p_ff_item->setItemValue(Ripple2BoxItem::P_WIDTH, p_sample->getWidth());
p_ff_item->setItemValue(Ripple2BoxItem::P_HEIGHT, p_sample->getHeight());
@@ -396,7 +396,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorRipple2Box* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorRipple2Gauss* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::Ripple2GaussType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Ripple2Gauss");
p_ff_item->setItemValue(Ripple2GaussItem::P_LENGTH, p_sample->getLength());
p_ff_item->setItemValue(Ripple2GaussItem::P_WIDTH, p_sample->getWidth());
p_ff_item->setItemValue(Ripple2GaussItem::P_HEIGHT, p_sample->getHeight());
@@ -407,7 +407,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorRipple2Gauss* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorRipple2Lorentz* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::Ripple2LorentzType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Ripple2Lorentz");
p_ff_item->setItemValue(Ripple2LorentzItem::P_LENGTH, p_sample->getLength());
p_ff_item->setItemValue(Ripple2LorentzItem::P_WIDTH, p_sample->getWidth());
p_ff_item->setItemValue(Ripple2LorentzItem::P_HEIGHT, p_sample->getHeight());
@@ -418,7 +418,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorRipple2Lorentz* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorTetrahedron* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::TetrahedronType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "Tetrahedron");
p_ff_item->setItemValue(TetrahedronItem::P_BASEEDGE, p_sample->getBaseEdge());
p_ff_item->setItemValue(TetrahedronItem::P_HEIGHT, p_sample->getHeight());
p_ff_item->setItemValue(TetrahedronItem::P_ALPHA, Units::rad2deg(p_sample->getAlpha()));
@@ -428,7 +428,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorTetrahedron* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorTruncatedCube* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::TruncatedCubeType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "TruncatedCube");
p_ff_item->setItemValue(TruncatedCubeItem::P_LENGTH, p_sample->getLength());
p_ff_item->setItemValue(TruncatedCubeItem::P_REMOVED_LENGTH, p_sample->getRemovedLength());
m_levelToParentItem[depth()] = p_particle_item;
@@ -437,7 +437,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorTruncatedCube* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorTruncatedSphere* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::TruncatedSphereType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "TruncatedSphere");
p_ff_item->setItemValue(TruncatedSphereItem::P_RADIUS, p_sample->getRadius());
p_ff_item->setItemValue(TruncatedSphereItem::P_HEIGHT, p_sample->getHeight());
p_ff_item->setItemValue(TruncatedSphereItem::P_REMOVED_TOP, p_sample->getRemovedTop());
@@ -447,7 +447,7 @@ void GUIDomainSampleVisitor::visit(const FormFactorTruncatedSphere* p_sample)
void GUIDomainSampleVisitor::visit(const FormFactorTruncatedSpheroid* p_sample)
{
SessionItem* p_particle_item = m_levelToParentItem[depth() - 1];
- SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, Constants::TruncatedSpheroidType);
+ SessionItem* p_ff_item = AddFormFactorItem(p_particle_item, "TruncatedSpheroid");
p_ff_item->setItemValue(TruncatedSpheroidItem::P_RADIUS, p_sample->getRadius());
p_ff_item->setItemValue(TruncatedSpheroidItem::P_HEIGHT, p_sample->getHeight());
p_ff_item->setItemValue(TruncatedSpheroidItem::P_HFC, p_sample->getHeightFlattening());
@@ -459,7 +459,7 @@ void GUIDomainSampleVisitor::visit(const InterferenceFunction1DLattice* p_sample
{
SessionItem* parent = m_levelToParentItem[depth() - 1];
Q_ASSERT(parent);
- SessionItem* item = m_sampleModel->insertNewItem(Constants::InterferenceFunction1DLatticeType,
+ SessionItem* item = m_sampleModel->insertNewItem("Interference1DLattice",
m_sampleModel->indexOfItem(parent), -1,
ParticleLayoutItem::T_INTERFERENCE);
Q_ASSERT(item);
@@ -471,7 +471,7 @@ void GUIDomainSampleVisitor::visit(const InterferenceFunction2DLattice* p_sample
{
SessionItem* parent = m_levelToParentItem[depth() - 1];
Q_ASSERT(parent);
- SessionItem* item = m_sampleModel->insertNewItem(Constants::InterferenceFunction2DLatticeType,
+ SessionItem* item = m_sampleModel->insertNewItem("Interference2DLattice",
m_sampleModel->indexOfItem(parent), -1,
ParticleLayoutItem::T_INTERFERENCE);
Q_ASSERT(item);
@@ -484,7 +484,7 @@ void GUIDomainSampleVisitor::visit(const InterferenceFunction2DParaCrystal* p_sa
SessionItem* parent = m_levelToParentItem[depth() - 1];
Q_ASSERT(parent);
SessionItem* item = m_sampleModel->insertNewItem(
- Constants::InterferenceFunction2DParaCrystalType, m_sampleModel->indexOfItem(parent), -1,
+ "Interference2DParaCrystal", m_sampleModel->indexOfItem(parent), -1,
ParticleLayoutItem::T_INTERFERENCE);
Q_ASSERT(item);
TransformFromDomain::set2DParaCrystalItem(item, *p_sample);
@@ -496,7 +496,7 @@ void GUIDomainSampleVisitor::visit(const InterferenceFunctionFinite2DLattice* p_
SessionItem* parent = m_levelToParentItem[depth() - 1];
Q_ASSERT(parent);
SessionItem* item = m_sampleModel->insertNewItem(
- Constants::InterferenceFunctionFinite2DLatticeType, m_sampleModel->indexOfItem(parent), -1,
+ "InterferenceFinite2DLattice", m_sampleModel->indexOfItem(parent), -1,
ParticleLayoutItem::T_INTERFERENCE);
Q_ASSERT(item);
TransformFromDomain::setFinite2DLatticeItem(item, *p_sample);
@@ -507,7 +507,7 @@ void GUIDomainSampleVisitor::visit(const InterferenceFunctionHardDisk* p_sample)
{
SessionItem* parent = m_levelToParentItem[depth() - 1];
Q_ASSERT(parent);
- SessionItem* item = m_sampleModel->insertNewItem(Constants::InterferenceFunctionHardDiskType,
+ SessionItem* item = m_sampleModel->insertNewItem("InterferenceHardDisk",
m_sampleModel->indexOfItem(parent), -1,
ParticleLayoutItem::T_INTERFERENCE);
Q_ASSERT(item);
@@ -520,7 +520,7 @@ void GUIDomainSampleVisitor::visit(const InterferenceFunctionRadialParaCrystal*
SessionItem* parent = m_levelToParentItem[depth() - 1];
Q_ASSERT(parent);
SessionItem* item = m_sampleModel->insertNewItem(
- Constants::InterferenceFunctionRadialParaCrystalType, m_sampleModel->indexOfItem(parent),
+ "InterferenceRadialParaCrystal", m_sampleModel->indexOfItem(parent),
-1, ParticleLayoutItem::T_INTERFERENCE);
Q_ASSERT(item);
TransformFromDomain::setRadialParaCrystalItem(item, *p_sample);
@@ -533,10 +533,10 @@ void GUIDomainSampleVisitor::visit(const RotationX* p_sample)
Q_ASSERT(parent);
SessionItem* transformation_item =
- m_sampleModel->insertNewItem(Constants::RotationType, m_sampleModel->indexOfItem(parent),
+ m_sampleModel->insertNewItem("Rotation", m_sampleModel->indexOfItem(parent),
-1, ParticleItem::T_TRANSFORMATION);
SessionItem* p_rotationItem =
- transformation_item->setGroupProperty(TransformationItem::P_ROT, Constants::XRotationType);
+ transformation_item->setGroupProperty(TransformationItem::P_ROT, "XRotation");
p_rotationItem->setItemValue(XRotationItem::P_ANGLE, Units::rad2deg(p_sample->getAngle()));
m_levelToParentItem[depth()] = transformation_item;
}
@@ -547,10 +547,10 @@ void GUIDomainSampleVisitor::visit(const RotationY* p_sample)
Q_ASSERT(parent);
SessionItem* transformation_item =
- m_sampleModel->insertNewItem(Constants::RotationType, m_sampleModel->indexOfItem(parent),
+ m_sampleModel->insertNewItem("Rotation", m_sampleModel->indexOfItem(parent),
-1, ParticleItem::T_TRANSFORMATION);
SessionItem* p_rotationItem =
- transformation_item->setGroupProperty(TransformationItem::P_ROT, Constants::YRotationType);
+ transformation_item->setGroupProperty(TransformationItem::P_ROT, "YRotation");
p_rotationItem->setItemValue(YRotationItem::P_ANGLE, Units::rad2deg(p_sample->getAngle()));
m_levelToParentItem[depth()] = transformation_item;
}
@@ -561,10 +561,10 @@ void GUIDomainSampleVisitor::visit(const RotationZ* p_sample)
Q_ASSERT(parent);
SessionItem* transformation_item =
- m_sampleModel->insertNewItem(Constants::RotationType, m_sampleModel->indexOfItem(parent),
+ m_sampleModel->insertNewItem("Rotation", m_sampleModel->indexOfItem(parent),
-1, ParticleItem::T_TRANSFORMATION);
SessionItem* p_rotationItem =
- transformation_item->setGroupProperty(TransformationItem::P_ROT, Constants::ZRotationType);
+ transformation_item->setGroupProperty(TransformationItem::P_ROT, "ZRotation");
p_rotationItem->setItemValue(ZRotationItem::P_ANGLE, Units::rad2deg(p_sample->getAngle()));
m_levelToParentItem[depth()] = transformation_item;
}
@@ -575,11 +575,11 @@ void GUIDomainSampleVisitor::visit(const RotationEuler* p_sample)
Q_ASSERT(parent);
SessionItem* transformation_item =
- m_sampleModel->insertNewItem(Constants::RotationType, m_sampleModel->indexOfItem(parent),
+ m_sampleModel->insertNewItem("Rotation", m_sampleModel->indexOfItem(parent),
-1, ParticleItem::T_TRANSFORMATION);
Q_ASSERT(transformation_item);
SessionItem* p_rotationItem = transformation_item->setGroupProperty(
- TransformationItem::P_ROT, Constants::EulerRotationType);
+ TransformationItem::P_ROT, "EulerRotation");
p_rotationItem->setItemValue(EulerRotationItem::P_ALPHA, Units::rad2deg(p_sample->getAlpha()));
p_rotationItem->setItemValue(EulerRotationItem::P_BETA, Units::rad2deg(p_sample->getBeta()));
p_rotationItem->setItemValue(EulerRotationItem::P_GAMMA, Units::rad2deg(p_sample->getGamma()));
@@ -625,8 +625,8 @@ SessionItem* GUIDomainSampleVisitor::InsertIParticle(const IParticle* p_particle
QString tag;
auto parent_type = p_parent->modelType();
- if (model_type == Constants::ParticleType) {
- if (parent_type == Constants::ParticleCoreShellType) {
+ if (model_type == "Particle") {
+ if (parent_type == "ParticleCoreShell") {
const ParticleCoreShell* p_coreshell =
dynamic_cast<const ParticleCoreShell*>(m_itemToSample[p_parent]);
Q_ASSERT(p_coreshell);
@@ -659,9 +659,9 @@ SessionItem* AddFormFactorItem(SessionItem* p_parent, const QString& model_type)
{
auto parent_type = p_parent->modelType();
QString property_name;
- if (parent_type == Constants::ParticleType) {
+ if (parent_type == "Particle") {
property_name = ParticleItem::P_FORM_FACTOR;
- } else if (parent_type == Constants::MesoCrystalType) {
+ } else if (parent_type == "MesoCrystal") {
property_name = MesoCrystalItem::P_FORM_FACTOR;
}
if (property_name.isEmpty()) {
diff --git a/GUI/coregui/Models/GUIObjectBuilder.cpp b/GUI/coregui/Models/GUIObjectBuilder.cpp
index 430c030560f936e33069a12b6b84838b88bb9039..48effa32b40aab7b148e5484e103f87f613d5b31 100644
--- a/GUI/coregui/Models/GUIObjectBuilder.cpp
+++ b/GUI/coregui/Models/GUIObjectBuilder.cpp
@@ -89,18 +89,18 @@ SessionItem* GUIObjectBuilder::populateDocumentModel(DocumentModel* p_document_m
const Simulation& simulation)
{
SimulationOptionsItem* p_options_item = dynamic_cast<SimulationOptionsItem*>(
- p_document_model->insertNewItem(Constants::SimulationOptionsType));
+ p_document_model->insertNewItem("SimulationOptions"));
Q_ASSERT(p_options_item);
if (simulation.getOptions().isIntegrate()) {
- p_options_item->setComputationMethod(Constants::SIMULATION_MONTECARLO);
+ p_options_item->setComputationMethod("Monte-Carlo Integration");
p_options_item->setNumberOfMonteCarloPoints(
static_cast<int>(simulation.getOptions().getMcPoints()));
}
if (simulation.getOptions().useAvgMaterials()) {
- p_options_item->setFresnelMaterialMethod(Constants::AVERAGE_LAYER_MATERIAL);
+ p_options_item->setFresnelMaterialMethod("Average Layer Material");
}
if (simulation.getOptions().includeSpecular()) {
- p_options_item->setIncludeSpecularPeak(Constants::Yes);
+ p_options_item->setIncludeSpecularPeak("Yes");
}
return p_options_item;
}
@@ -112,7 +112,7 @@ GISASInstrumentItem* createGISASInstrumentItem(InstrumentModel* model,
const QString& name)
{
auto result =
- dynamic_cast<GISASInstrumentItem*>(model->insertNewItem(Constants::GISASInstrumentType));
+ dynamic_cast<GISASInstrumentItem*>(model->insertNewItem("GISASInstrument"));
result->setItemName(name);
TransformFromDomain::setGISASBeamItem(result->beamItem(), simulation);
@@ -127,7 +127,7 @@ OffSpecInstrumentItem* createOffSpecInstrumentItem(InstrumentModel* model,
const QString& name)
{
auto result = dynamic_cast<OffSpecInstrumentItem*>(
- model->insertNewItem(Constants::OffSpecInstrumentType));
+ model->insertNewItem("OffSpecInstrument"));
result->setItemName(name);
TransformFromDomain::setOffSpecBeamItem(result->beamItem(), simulation);
@@ -145,7 +145,7 @@ SpecularInstrumentItem* createSpecularInstrumentItem(InstrumentModel* model,
const QString& name)
{
auto result = dynamic_cast<SpecularInstrumentItem*>(
- model->insertNewItem(Constants::SpecularInstrumentType));
+ model->insertNewItem("SpecularInstrument"));
result->setItemName(name);
TransformFromDomain::setSpecularBeamItem(result->beamItem(), simulation);
diff --git a/GUI/coregui/Models/GroupInfoCatalogue.cpp b/GUI/coregui/Models/GroupInfoCatalogue.cpp
index ecf9dd6b9f699a66c6837b2342cdd4cb384839bd..07c3a31138405239495144eee0a2a714a4c4a2b8 100644
--- a/GUI/coregui/Models/GroupInfoCatalogue.cpp
+++ b/GUI/coregui/Models/GroupInfoCatalogue.cpp
@@ -13,189 +13,188 @@
// ************************************************************************** //
#include "GUI/coregui/Models/GroupInfoCatalogue.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/utils/GUIHelpers.h"
GroupInfoCatalogue::GroupInfoCatalogue()
{
- GroupInfo info(Constants::FormFactorGroup);
- info.add(Constants::AnisoPyramidType, "Aniso Pyramid");
- info.add(Constants::BarGaussType, "BarGauss");
- info.add(Constants::BarLorentzType, "BarLorentz");
- info.add(Constants::BoxType, "Box");
- info.add(Constants::ConeType, "Cone");
- info.add(Constants::Cone6Type, "Cone6");
- info.add(Constants::CuboctahedronType, "Cuboctahedron");
- info.add(Constants::CylinderType, "Cylinder");
- info.add(Constants::DodecahedronType, "Dodecahedron");
- info.add(Constants::DotType, "Dot");
- info.add(Constants::EllipsoidalCylinderType, "Ellipsoidal Cylinder");
- info.add(Constants::FullSphereType, "Full Sphere");
- info.add(Constants::FullSpheroidType, "Full Spheroid");
- info.add(Constants::HemiEllipsoidType, "Hemi Ellipsoid");
- info.add(Constants::IcosahedronType, "Icosahedron");
- info.add(Constants::Prism3Type, "Prism3");
- info.add(Constants::Prism6Type, "Prism6");
- info.add(Constants::PyramidType, "Pyramid");
- info.add(Constants::Ripple1BoxType, "Ripple1Box");
- info.add(Constants::Ripple1GaussType, "Ripple1Gauss");
- info.add(Constants::Ripple1LorentzType, "Ripple1Lorentz");
- info.add(Constants::Ripple2BoxType, "Ripple2Box");
- info.add(Constants::Ripple2GaussType, "Ripple2Gauss");
- info.add(Constants::Ripple2LorentzType, "Ripple2Lorentz");
- info.add(Constants::TetrahedronType, "Tetrahedron");
- info.add(Constants::TruncatedCubeType, "Truncated Cube");
- info.add(Constants::TruncatedSphereType, "Truncated Sphere");
- info.add(Constants::TruncatedSpheroidType, "Truncated Spheroid");
- info.setDefaultType(Constants::CylinderType);
- addInfo(info);
-
- info = GroupInfo(Constants::RotationGroup);
- info.add(Constants::XRotationType, "X axis Rotation");
- info.add(Constants::YRotationType, "Y axis Rotation");
- info.add(Constants::ZRotationType, "Z axis Rotation");
- info.add(Constants::EulerRotationType, "Euler Rotation");
- info.setDefaultType(Constants::ZRotationType);
- addInfo(info);
-
- info = GroupInfo(Constants::LayerRoughnessGroup);
- info.add(Constants::LayerBasicRoughnessType, "Basic");
- info.add(Constants::LayerZeroRoughnessType, "No");
- info.setDefaultType(Constants::LayerZeroRoughnessType);
- addInfo(info);
-
- info = GroupInfo(Constants::DetectorGroup);
- info.add(Constants::SphericalDetectorType, "Spherical detector");
- info.add(Constants::RectangularDetectorType, "Rectangular detector");
- info.setDefaultType(Constants::SphericalDetectorType);
- addInfo(info);
-
- info = GroupInfo(Constants::DistributionGroup);
- info.add(Constants::DistributionGateType, "Gate distribution");
- info.add(Constants::DistributionLorentzType, "Lorentz distribution");
- info.add(Constants::DistributionGaussianType, "Gaussian distribution");
- info.add(Constants::DistributionLogNormalType, "Log Normal distribution");
- info.add(Constants::DistributionCosineType, "Cosine distribution");
- info.add(Constants::DistributionTrapezoidType, "Trapezoid distribution");
- info.setDefaultType(Constants::DistributionGaussianType);
- addInfo(info);
-
- info = GroupInfo(Constants::DistributionExtendedGroup);
- info.add(Constants::DistributionNoneType, "None");
- info.add(Constants::DistributionGateType, "Gate");
- info.add(Constants::DistributionLorentzType, "Lorentz");
- info.add(Constants::DistributionGaussianType, "Gaussian");
- info.add(Constants::DistributionLogNormalType, "Log Normal");
- info.add(Constants::DistributionCosineType, "Cosine");
- info.add(Constants::DistributionTrapezoidType, "Trapezoid");
- info.setDefaultType(Constants::DistributionNoneType);
- addInfo(info);
-
- info = GroupInfo(Constants::SymmetricDistributionGroup);
- info.add(Constants::DistributionNoneType, "None");
- info.add(Constants::DistributionLorentzType, "Lorentz");
- info.add(Constants::DistributionGaussianType, "Gaussian");
- info.add(Constants::DistributionCosineType, "Cosine");
- info.setDefaultType(Constants::DistributionNoneType);
- addInfo(info);
-
- info = GroupInfo(Constants::FTDistribution1DGroup);
- info.add(Constants::FTDistribution1DCauchyType, "Cauchy 1D");
- info.add(Constants::FTDistribution1DGaussType, "Gauss 1D");
- info.add(Constants::FTDistribution1DGateType, "Gate 1D");
- info.add(Constants::FTDistribution1DTriangleType, "Triangle 1D");
- info.add(Constants::FTDistribution1DCosineType, "Cosine 1D");
- info.add(Constants::FTDistribution1DVoigtType, "Voigt 1D");
- info.setDefaultType(Constants::FTDistribution1DCauchyType);
- addInfo(info);
-
- info = GroupInfo(Constants::FTDistribution2DGroup);
- info.add(Constants::FTDistribution2DCauchyType, "Cauchy 2D");
- info.add(Constants::FTDistribution2DGaussType, "Gauss 2D");
- info.add(Constants::FTDistribution2DGateType, "Gate 2D");
- info.add(Constants::FTDistribution2DConeType, "Cone 2D");
- info.add(Constants::FTDistribution2DVoigtType, "Voigt 2D");
- info.setDefaultType(Constants::FTDistribution2DCauchyType);
- addInfo(info);
-
- info = GroupInfo(Constants::FTDecayFunction1DGroup);
- info.add(Constants::FTDecayFunction1DCauchyType, "Cauchy 1D");
- info.add(Constants::FTDecayFunction1DGaussType, "Gauss 1D");
- info.add(Constants::FTDecayFunction1DTriangleType, "Triangle 1D");
- info.add(Constants::FTDecayFunction1DVoigtType, "Voigt 1D");
- info.setDefaultType(Constants::FTDecayFunction1DCauchyType);
- addInfo(info);
-
- info = GroupInfo(Constants::FTDecayFunction2DGroup);
- info.add(Constants::FTDecayFunction2DCauchyType, "Cauchy 2D");
- info.add(Constants::FTDecayFunction2DGaussType, "Gauss 2D");
- info.add(Constants::FTDecayFunction2DVoigtType, "Voigt 2D");
- info.setDefaultType(Constants::FTDecayFunction2DCauchyType);
- addInfo(info);
-
- info = GroupInfo(Constants::LatticeGroup);
- info.add(Constants::BasicLatticeType, "Basic");
- info.add(Constants::SquareLatticeType, "Square");
- info.add(Constants::HexagonalLatticeType, "Hexagonal");
- info.setDefaultType(Constants::HexagonalLatticeType);
- addInfo(info);
-
- info = GroupInfo(Constants::ResolutionFunctionGroup);
- info.add(Constants::ResolutionFunctionNoneType, "None");
- info.add(Constants::ResolutionFunction2DGaussianType, "2D Gaussian");
- info.setDefaultType(Constants::ResolutionFunctionNoneType);
+ GroupInfo info("Form Factor");
+ info.add("AnisoPyramid", "Aniso Pyramid");
+ info.add("BarGauss", "BarGauss");
+ info.add("BarLorentz", "BarLorentz");
+ info.add("Box", "Box");
+ info.add("Cone", "Cone");
+ info.add("Cone6", "Cone6");
+ info.add("Cuboctahedron", "Cuboctahedron");
+ info.add("Cylinder", "Cylinder");
+ info.add("Dodecahedron", "Dodecahedron");
+ info.add("Dot", "Dot");
+ info.add("EllipsoidalCylinder", "Ellipsoidal Cylinder");
+ info.add("FullSphere", "Full Sphere");
+ info.add("FullSpheroid", "Full Spheroid");
+ info.add("HemiEllipsoid", "Hemi Ellipsoid");
+ info.add("Icosahedron", "Icosahedron");
+ info.add("Prism3", "Prism3");
+ info.add("Prism6", "Prism6");
+ info.add("Pyramid", "Pyramid");
+ info.add("Ripple1Box", "Ripple1Box");
+ info.add("Ripple1Gauss", "Ripple1Gauss");
+ info.add("Ripple1Lorentz", "Ripple1Lorentz");
+ info.add("Ripple2Box", "Ripple2Box");
+ info.add("Ripple2Gauss", "Ripple2Gauss");
+ info.add("Ripple2Lorentz", "Ripple2Lorentz");
+ info.add("Tetrahedron", "Tetrahedron");
+ info.add("TruncatedCube", "Truncated Cube");
+ info.add("TruncatedSphere", "Truncated Sphere");
+ info.add("TruncatedSpheroid", "Truncated Spheroid");
+ info.setDefaultType("Cylinder");
+ addInfo(info);
+
+ info = GroupInfo("Rotation group");
+ info.add("XRotation", "X axis Rotation");
+ info.add("YRotation", "Y axis Rotation");
+ info.add("ZRotation", "Z axis Rotation");
+ info.add("EulerRotation", "Euler Rotation");
+ info.setDefaultType("ZRotation");
+ addInfo(info);
+
+ info = GroupInfo("Roughness");
+ info.add("LayerBasicRoughness", "Basic");
+ info.add("LayerZeroRoughness", "No");
+ info.setDefaultType("LayerZeroRoughness");
+ addInfo(info);
+
+ info = GroupInfo("Detector group");
+ info.add("SphericalDetector", "Spherical detector");
+ info.add("RectangularDetector", "Rectangular detector");
+ info.setDefaultType("SphericalDetector");
+ addInfo(info);
+
+ info = GroupInfo("Distribution group");
+ info.add("DistributionGate", "Gate distribution");
+ info.add("DistributionLorentz", "Lorentz distribution");
+ info.add("DistributionGaussian", "Gaussian distribution");
+ info.add("DistributionLogNormal", "Log Normal distribution");
+ info.add("DistributionCosine", "Cosine distribution");
+ info.add("DistributionTrapezoid", "Trapezoid distribution");
+ info.setDefaultType("DistributionGaussian");
+ addInfo(info);
+
+ info = GroupInfo("Distribution extended group");
+ info.add("DistributionNone", "None");
+ info.add("DistributionGate", "Gate");
+ info.add("DistributionLorentz", "Lorentz");
+ info.add("DistributionGaussian", "Gaussian");
+ info.add("DistributionLogNormal", "Log Normal");
+ info.add("DistributionCosine", "Cosine");
+ info.add("DistributionTrapezoid", "Trapezoid");
+ info.setDefaultType("DistributionNone");
+ addInfo(info);
+
+ info = GroupInfo("Symmetric distribution group");
+ info.add("DistributionNone", "None");
+ info.add("DistributionLorentz", "Lorentz");
+ info.add("DistributionGaussian", "Gaussian");
+ info.add("DistributionCosine", "Cosine");
+ info.setDefaultType("DistributionNone");
+ addInfo(info);
+
+ info = GroupInfo("PDF 1D");
+ info.add("FTDistribution1DCauchy", "Cauchy 1D");
+ info.add("FTDistribution1DGauss", "Gauss 1D");
+ info.add("FTDistribution1DGate", "Gate 1D");
+ info.add("FTDistribution1DTriangle", "Triangle 1D");
+ info.add("FTDistribution1DCosine", "Cosine 1D");
+ info.add("FTDistribution1DVoigt", "Voigt 1D");
+ info.setDefaultType("FTDistribution1DCauchy");
+ addInfo(info);
+
+ info = GroupInfo("PDF 2D");
+ info.add("FTDistribution2DCauchy", "Cauchy 2D");
+ info.add("FTDistribution2DGauss", "Gauss 2D");
+ info.add("FTDistribution2DGate", "Gate 2D");
+ info.add("FTDistribution2DCone", "Cone 2D");
+ info.add("FTDistribution2DVoigt", "Voigt 2D");
+ info.setDefaultType("FTDistribution2DCauchy");
+ addInfo(info);
+
+ info = GroupInfo("Decay function 1D");
+ info.add("FTDecayFunction1DCauchy", "Cauchy 1D");
+ info.add("FTDecayFunction1DGauss", "Gauss 1D");
+ info.add("FTDecayFunction1DTriangle", "Triangle 1D");
+ info.add("FTDecayFunction1DVoigt", "Voigt 1D");
+ info.setDefaultType("FTDecayFunction1DCauchy");
+ addInfo(info);
+
+ info = GroupInfo("Decay function 2D");
+ info.add("FTDecayFunction2DCauchy", "Cauchy 2D");
+ info.add("FTDecayFunction2DGauss", "Gauss 2D");
+ info.add("FTDecayFunction2DVoigt", "Voigt 2D");
+ info.setDefaultType("FTDecayFunction2DCauchy");
+ addInfo(info);
+
+ info = GroupInfo("Lattice group");
+ info.add("BasicLattice", "Basic");
+ info.add("SquareLattice", "Square");
+ info.add("HexagonalLattice", "Hexagonal");
+ info.setDefaultType("HexagonalLattice");
+ addInfo(info);
+
+ info = GroupInfo("Resolution function group");
+ info.add("ResolutionFunctionNone", "None");
+ info.add("ResolutionFunction2DGaussian", "2D Gaussian");
+ info.setDefaultType("ResolutionFunctionNone");
addInfo(info);
- info = GroupInfo(Constants::MinimizerLibraryGroup);
- info.add(Constants::MinuitMinimizerType, "Minuit2");
- info.add(Constants::GSLMultiMinimizerType, "GSL MultiMin");
- info.add(Constants::GeneticMinimizerType, "TMVA Genetic");
- info.add(Constants::GSLSimAnMinimizerType, "GSL Simulated Annealing");
- info.add(Constants::GSLLMAMinimizerType, "GSL Levenberg-Marquardt");
- info.add(Constants::TestMinimizerType, "Test minimizer");
- info.setDefaultType(Constants::MinuitMinimizerType);
+ info = GroupInfo("Minimizer library group");
+ info.add("Minuit2", "Minuit2");
+ info.add("GSLMultiMin", "GSL MultiMin");
+ info.add("Genetic", "TMVA Genetic");
+ info.add("GSLSimAn", "GSL Simulated Annealing");
+ info.add("GSLLMA", "GSL Levenberg-Marquardt");
+ info.add("Test", "Test minimizer");
+ info.setDefaultType("Minuit2");
addInfo(info);
- info = GroupInfo(Constants::RealLimitsGroup);
- info.add(Constants::RealLimitsLimitlessType, "Unlimited");
- info.add(Constants::RealLimitsPositiveType, "Positive");
- info.add(Constants::RealLimitsNonnegativeType, "Nonnegative");
- info.add(Constants::RealLimitsLowerLimitedType, "LowerLimited");
- info.add(Constants::RealLimitsUpperLimitedType, "UpperLimited");
- info.add(Constants::RealLimitsLimitedType, "Limited");
- info.setDefaultType(Constants::RealLimitsLimitlessType);
- addInfo(info);
+ info = GroupInfo("RealLimits group");
+ info.add("RealLimitsLimitless", "Unlimited");
+ info.add("RealLimitsPositive", "Positive");
+ info.add("RealLimitsNonnegative", "Nonnegative");
+ info.add("RealLimitsLowerLimited", "LowerLimited");
+ info.add("RealLimitsUpperLimited", "UpperLimited");
+ info.add("RealLimitsLimited", "Limited");
+ info.setDefaultType("RealLimitsLimitless");
+ addInfo(info);
- info = GroupInfo(Constants::BackgroundGroup);
- info.add(Constants::BackgroundNoneType, "None");
- info.add(Constants::ConstantBackgroundType, "Constant background");
- info.add(Constants::PoissonNoiseBackgroundType, "Poisson noise");
- info.setDefaultType(Constants::BackgroundNoneType);
- addInfo(info);
-
- info = GroupInfo(Constants::MaterialDataGroup);
- info.add(Constants::MaterialRefractiveDataType, "Refractive index based");
- info.add(Constants::MaterialSLDDataType, "SLD based");
- info.setDefaultType(Constants::MaterialRefractiveDataType);
+ info = GroupInfo("Background group");
+ info.add("NoBackground", "None");
+ info.add("ConstantBackground", "Constant background");
+ info.add("PoissonNoiseBackground", "Poisson noise");
+ info.setDefaultType("NoBackground");
+ addInfo(info);
+
+ info = GroupInfo("Material data group");
+ info.add("MaterialRefractiveData", "Refractive index based");
+ info.add("MaterialSLDData", "SLD based");
+ info.setDefaultType("MaterialRefractiveData");
addInfo(info);
- info = GroupInfo(Constants::FootprintGroup);
- info.add(Constants::FootprintNoneType, "None");
- info.add(Constants::FootprintGaussianType, "Gaussian footprint");
- info.add(Constants::FootprintSquareType, "Square footprint");
- info.setDefaultType(Constants::FootprintNoneType);
+ info = GroupInfo("Footprint group");
+ info.add("NoFootprint", "None");
+ info.add("GaussianFootrpint", "Gaussian footprint");
+ info.add("SquareFootprint", "Square footprint");
+ info.setDefaultType("NoFootprint");
addInfo(info);
- info = GroupInfo(Constants::AxesGroup);
- info.add(Constants::BasicAxisType, "Uniform axis");
- info.add(Constants::PointwiseAxisType, "Non-uniform axis");
- info.setDefaultType(Constants::BasicAxisType);
+ info = GroupInfo("Axes group");
+ info.add("BasicAxis", "Uniform axis");
+ info.add("PointwiseAxis", "Non-uniform axis");
+ info.setDefaultType("BasicAxis");
addInfo(info);
- info = GroupInfo(Constants::VarianceFunctionGroup);
- info.add(Constants::VarianceSimFunctionType, "Simulation value based");
- info.add(Constants::VarianceConstantFunctionType, "Constant");
- info.setDefaultType(Constants::VarianceSimFunctionType);
+ info = GroupInfo("Variance group");
+ info.add("VarianceSimFunction", "Simulation value based");
+ info.add("VarianceConstantFunction", "Constant");
+ info.setDefaultType("VarianceSimFunction");
addInfo(info);
}
diff --git a/GUI/coregui/Models/GroupItem.cpp b/GUI/coregui/Models/GroupItem.cpp
index 2c6aea9d4850416446f330c6814764f542b51814..154533cd9b023e9f2ea20f89fd6f1dcceb7e826e 100644
--- a/GUI/coregui/Models/GroupItem.cpp
+++ b/GUI/coregui/Models/GroupItem.cpp
@@ -19,7 +19,7 @@
const QString GroupItem::T_ITEMS = "Item tag";
-GroupItem::GroupItem() : SessionItem(Constants::GroupItemType)
+GroupItem::GroupItem() : SessionItem("GroupProperty")
{
registerTag(T_ITEMS);
setDefaultTag(T_ITEMS);
diff --git a/GUI/coregui/Models/InstrumentItems.cpp b/GUI/coregui/Models/InstrumentItems.cpp
index 0d29aa6613e09f14f37d8fa1fae7aca5d279b220..f82d74f369636d83af1d50d494a064471977556a 100644
--- a/GUI/coregui/Models/InstrumentItems.cpp
+++ b/GUI/coregui/Models/InstrumentItems.cpp
@@ -33,8 +33,8 @@
namespace
{
const QString background_group_label = "Type";
-const QStringList instrument_names{Constants::GISASInstrumentType, Constants::OffSpecInstrumentType,
- Constants::SpecularInstrumentType};
+const QStringList instrument_names{"GISASInstrument", "OffSpecInstrument",
+ "SpecularInstrument"};
void addAxisGroupProperty(SessionItem* parent, const QString& tag);
} // namespace
@@ -100,14 +100,14 @@ void InstrumentItem::initBeamGroup(const QString& beam_model)
void InstrumentItem::initBackgroundGroup()
{
- auto item = addGroupProperty(P_BACKGROUND, Constants::BackgroundGroup);
+ auto item = addGroupProperty(P_BACKGROUND, "Background group");
item->setDisplayName(background_group_label);
item->setToolTip("Background type");
}
-SpecularInstrumentItem::SpecularInstrumentItem() : InstrumentItem(Constants::SpecularInstrumentType)
+SpecularInstrumentItem::SpecularInstrumentItem() : InstrumentItem("SpecularInstrument")
{
- initBeamGroup(Constants::SpecularBeamType);
+ initBeamGroup("SpecularBeam");
initBackgroundGroup();
item<SpecularBeamItem>(P_BEAM).updateFileName(ItemFileNameUtils::instrumentDataFileName(*this));
}
@@ -144,8 +144,8 @@ void SpecularInstrumentItem::updateToRealData(const RealDataItem* item)
bool SpecularInstrumentItem::alignedWith(const RealDataItem* item) const
{
const QString native_units = item->getItemValue(RealDataItem::P_NATIVE_UNITS).toString();
- if (native_units == Constants::UnitsNbins) {
- return beamItem()->currentInclinationAxisItem()->modelType() == Constants::BasicAxisType
+ if (native_units == "nbins") {
+ return beamItem()->currentInclinationAxisItem()->modelType() == "BasicAxis"
&& shape() == item->shape();
} else {
auto axis_item = dynamic_cast<PointwiseAxisItem*>(beamItem()->currentInclinationAxisItem());
@@ -183,8 +183,8 @@ const QString Instrument2DItem::P_DETECTOR = "Detector";
Instrument2DItem::Instrument2DItem(const QString& modelType) : InstrumentItem(modelType)
{
- initBeamGroup(Constants::GISASBeamType);
- addGroupProperty(P_DETECTOR, Constants::DetectorGroup);
+ initBeamGroup("GISASBeam");
+ addGroupProperty(P_DETECTOR, "Detector group");
initBackgroundGroup();
setDefaultTag(P_DETECTOR);
@@ -227,7 +227,7 @@ std::unique_ptr<Instrument> Instrument2DItem::createInstrument() const
return result;
}
-GISASInstrumentItem::GISASInstrumentItem() : Instrument2DItem(Constants::GISASInstrumentType) {}
+GISASInstrumentItem::GISASInstrumentItem() : Instrument2DItem("GISASInstrument") {}
std::vector<int> GISASInstrumentItem::shape() const
{
@@ -250,7 +250,7 @@ void GISASInstrumentItem::updateToRealData(const RealDataItem* item)
const QString OffSpecInstrumentItem::P_ALPHA_AXIS = "Alpha axis";
-OffSpecInstrumentItem::OffSpecInstrumentItem() : Instrument2DItem(Constants::OffSpecInstrumentType)
+OffSpecInstrumentItem::OffSpecInstrumentItem() : Instrument2DItem("OffSpecInstrument")
{
addAxisGroupProperty(this, P_ALPHA_AXIS);
auto inclination_item = getItem(P_ALPHA_AXIS)->getItem(BasicAxisItem::P_MIN);
@@ -287,7 +287,7 @@ namespace
{
void addAxisGroupProperty(SessionItem* parent, const QString& tag)
{
- auto item = parent->addGroupProperty(tag, Constants::BasicAxisType);
+ auto item = parent->addGroupProperty(tag, "BasicAxis");
item->setToolTip("Incoming alpha range [deg]");
item->getItem(BasicAxisItem::P_TITLE)->setVisible(false);
item->getItem(BasicAxisItem::P_NBINS)->setToolTip("Number of points in scan");
diff --git a/GUI/coregui/Models/InstrumentModel.cpp b/GUI/coregui/Models/InstrumentModel.cpp
index a4597317e4fbca1e4044ed5e1c5d81e52022230c..6c31e42b8200a1aa6206d685983389d1eac04b29 100644
--- a/GUI/coregui/Models/InstrumentModel.cpp
+++ b/GUI/coregui/Models/InstrumentModel.cpp
@@ -40,7 +40,7 @@ QVector<SessionItem*> InstrumentModel::nonXMLData() const
->getItem(BeamItem::P_INCLINATION_ANGLE)
->getItem(SpecularBeamInclinationItem::P_ALPHA_AXIS);
- if (auto pointwise_axis = axis_group->getChildOfType(Constants::PointwiseAxisType))
+ if (auto pointwise_axis = axis_group->getChildOfType("PointwiseAxis"))
result.push_back(pointwise_axis);
}
diff --git a/GUI/coregui/Models/IntensityDataItem.cpp b/GUI/coregui/Models/IntensityDataItem.cpp
index aee41e7535c321744912e45c54e561c13c441281..8168396dbf03049cd1614ff4ad31a1c938a58554 100644
--- a/GUI/coregui/Models/IntensityDataItem.cpp
+++ b/GUI/coregui/Models/IntensityDataItem.cpp
@@ -27,12 +27,12 @@ namespace
ComboProperty gradientCombo()
{
ComboProperty result;
- result << Constants::GRADIENT_GRAYSCALE << Constants::GRADIENT_HOT << Constants::GRADIENT_COLD
- << Constants::GRADIENT_NIGHT << Constants::GRADIENT_CANDY
- << Constants::GRADIENT_GEOGRAPHY << Constants::GRADIENT_ION
- << Constants::GRADIENT_THERMAL << Constants::GRADIENT_POLAR
- << Constants::GRADIENT_SPECTRUM << Constants::GRADIENT_JET << Constants::GRADIENT_HUES;
- result.setValue(Constants::GRADIENT_JET);
+ result << "Grayscale" << "Hot" << "Cold"
+ << "Night" << "Candy"
+ << "Geography" << "Ion"
+ << "Thermal" << "Polar"
+ << "Spectrum" << "Jet" << "Hues";
+ result.setValue("Jet");
return result;
}
} // namespace
@@ -50,7 +50,7 @@ const QString IntensityDataItem::P_ZAXIS = "color-axis";
const QString IntensityDataItem::T_MASKS = "Mask tag";
const QString IntensityDataItem::T_PROJECTIONS = "Projection tag";
-IntensityDataItem::IntensityDataItem() : DataItem(Constants::IntensityDataType)
+IntensityDataItem::IntensityDataItem() : DataItem("IntensityData")
{
addProperty(P_TITLE, QString())->setVisible(false);
@@ -58,22 +58,22 @@ IntensityDataItem::IntensityDataItem() : DataItem(Constants::IntensityDataType)
addProperty(P_IS_INTERPOLATED, true);
addProperty(P_GRADIENT, gradientCombo().variant());
- SessionItem* item = addGroupProperty(P_XAXIS, Constants::BasicAxisType);
+ SessionItem* item = addGroupProperty(P_XAXIS, "BasicAxis");
item->getItem(BasicAxisItem::P_NBINS)->setVisible(false);
- item = addGroupProperty(P_YAXIS, Constants::BasicAxisType);
+ item = addGroupProperty(P_YAXIS, "BasicAxis");
item->getItem(BasicAxisItem::P_NBINS)->setVisible(false);
- item = addGroupProperty(P_ZAXIS, Constants::AmplitudeAxisType);
+ item = addGroupProperty(P_ZAXIS, "AmplitudeAxis");
item->getItem(BasicAxisItem::P_NBINS)->setVisible(false);
setXaxisTitle(x_axis_default_name);
setYaxisTitle(y_axis_default_name);
- registerTag(T_MASKS, 0, -1, QStringList() << Constants::MaskContainerType);
+ registerTag(T_MASKS, 0, -1, QStringList() << "MaskContainer");
setDefaultTag(T_MASKS);
- registerTag(T_PROJECTIONS, 0, -1, QStringList() << Constants::ProjectionContainerType);
+ registerTag(T_PROJECTIONS, 0, -1, QStringList() << "ProjectionContainer");
}
void IntensityDataItem::setOutputData(OutputData<double>* data)
@@ -227,7 +227,7 @@ std::vector<int> IntensityDataItem::shape() const
void IntensityDataItem::reset(ImportDataInfo data)
{
- assert(data.unitsLabel() == Constants::UnitsNbins);
+ assert(data.unitsLabel() == "nbins");
ComboProperty combo = ComboProperty() << data.unitsLabel();
setItemValue(IntensityDataItem::P_AXES_UNITS, combo.variant());
getItem(IntensityDataItem::P_AXES_UNITS)->setVisible(true);
diff --git a/GUI/coregui/Models/InterferenceFunctionItems.cpp b/GUI/coregui/Models/InterferenceFunctionItems.cpp
index c57e9be86596072aaed4e882108966f70ba21d98..c7500a35ad0e64dd17440b6725efb277845f361e 100644
--- a/GUI/coregui/Models/InterferenceFunctionItems.cpp
+++ b/GUI/coregui/Models/InterferenceFunctionItems.cpp
@@ -56,7 +56,7 @@ const QString InterferenceFunction1DLatticeItem::P_ROTATION_ANGLE = QString::fro
const QString InterferenceFunction1DLatticeItem::P_DECAY_FUNCTION = decay_function_tag;
InterferenceFunction1DLatticeItem::InterferenceFunction1DLatticeItem()
- : InterferenceFunctionItem(Constants::InterferenceFunction1DLatticeType)
+ : InterferenceFunctionItem("Interference1DLattice")
{
setToolTip(QStringLiteral("Interference function of a 1D lattice"));
addProperty(P_LENGTH, 20.0 * Units::nanometer)
@@ -64,7 +64,7 @@ InterferenceFunction1DLatticeItem::InterferenceFunction1DLatticeItem()
addProperty(P_ROTATION_ANGLE, 0.0)
->setToolTip(QStringLiteral("Rotation of lattice with respect to x-axis of reference \n"
"frame (beam direction) in degrees "));
- addGroupProperty(P_DECAY_FUNCTION, Constants::FTDecayFunction1DGroup)
+ addGroupProperty(P_DECAY_FUNCTION, "Decay function 1D")
->setToolTip(QStringLiteral("One-dimensional decay function (finite size effects)"));
}
@@ -88,11 +88,11 @@ const QString InterferenceFunction2DLatticeItem::P_DECAY_FUNCTION = decay_functi
const QString InterferenceFunction2DLatticeItem::P_XI_INTEGRATION = "Integration_over_xi";
InterferenceFunction2DLatticeItem::InterferenceFunction2DLatticeItem()
- : InterferenceFunctionItem(Constants::InterferenceFunction2DLatticeType)
+ : InterferenceFunctionItem("Interference2DLattice")
{
setToolTip(QStringLiteral("Interference function of a 2D lattice"));
- addGroupProperty(P_LATTICE_TYPE, Constants::LatticeGroup)->setToolTip("Type of lattice");
- addGroupProperty(P_DECAY_FUNCTION, Constants::FTDecayFunction2DGroup)
+ addGroupProperty(P_LATTICE_TYPE, "Lattice group")->setToolTip("Type of lattice");
+ addGroupProperty(P_DECAY_FUNCTION, "Decay function 2D")
->setToolTip("Two-dimensional decay function (finite size effects)");
addProperty(P_XI_INTEGRATION, false)
->setToolTip(QStringLiteral("Enables/disables averaging over the lattice rotation angle."));
@@ -103,7 +103,7 @@ InterferenceFunction2DLatticeItem::InterferenceFunction2DLatticeItem()
}
});
mapper()->setOnChildPropertyChange([this](SessionItem* item, const QString&) {
- if (item->modelType() == Constants::GroupItemType
+ if (item->modelType() == "GroupProperty"
&& item->displayName() == InterferenceFunction2DLatticeItem::P_LATTICE_TYPE) {
update_rotation_availability();
}
@@ -147,11 +147,11 @@ const QString InterferenceFunction2DParaCrystalItem::P_PDF1 = "PDF #1";
const QString InterferenceFunction2DParaCrystalItem::P_PDF2 = "PDF #2";
InterferenceFunction2DParaCrystalItem::InterferenceFunction2DParaCrystalItem()
- : InterferenceFunctionItem(Constants::InterferenceFunction2DParaCrystalType)
+ : InterferenceFunctionItem("Interference2DParaCrystal")
{
setToolTip(QStringLiteral("Interference function of a two-dimensional paracrystal"));
- addGroupProperty(InterferenceFunction2DLatticeItem::P_LATTICE_TYPE, Constants::LatticeGroup)
+ addGroupProperty(InterferenceFunction2DLatticeItem::P_LATTICE_TYPE, "Lattice group")
->setToolTip(QStringLiteral("Type of lattice"));
getGroupItem(InterferenceFunction2DLatticeItem::P_LATTICE_TYPE)
->getItem(Lattice2DItem::P_LATTICE_ROTATION_ANGLE)
@@ -169,9 +169,9 @@ InterferenceFunction2DParaCrystalItem::InterferenceFunction2DParaCrystalItem()
addProperty(P_DOMAIN_SIZE2, 20.0 * Units::micrometer)
->setToolTip(QStringLiteral(
"Size of the coherent domain along the second basis vector in nanometers"));
- addGroupProperty(P_PDF1, Constants::FTDistribution2DGroup)
+ addGroupProperty(P_PDF1, "PDF 2D")
->setToolTip(QStringLiteral("Probability distribution in first lattice direction"));
- addGroupProperty(P_PDF2, Constants::FTDistribution2DGroup)
+ addGroupProperty(P_PDF2, "PDF 2D")
->setToolTip(QStringLiteral("Probability distribution in second lattice direction"));
mapper()->setOnPropertyChange([this](const QString& name) {
@@ -181,11 +181,11 @@ InterferenceFunction2DParaCrystalItem::InterferenceFunction2DParaCrystalItem()
});
mapper()->setOnChildPropertyChange([this](SessionItem* item, const QString& property) {
- if (item->modelType() == Constants::GroupItemType
+ if (item->modelType() == "GroupProperty"
&& item->displayName() == InterferenceFunction2DLatticeItem::P_LATTICE_TYPE) {
update_rotation_availability();
}
- if (item->modelType() == Constants::GroupItemType && property == GroupItem::T_ITEMS
+ if (item->modelType() == "GroupProperty" && property == GroupItem::T_ITEMS
&& isTag(P_PDF1) && isTag(P_PDF2))
update_distribution_displaynames();
});
@@ -255,10 +255,10 @@ const QString InterferenceFunctionFinite2DLatticeItem::P_DOMAIN_SIZE_1 = "Domain
const QString InterferenceFunctionFinite2DLatticeItem::P_DOMAIN_SIZE_2 = "Domain_size_2";
InterferenceFunctionFinite2DLatticeItem::InterferenceFunctionFinite2DLatticeItem()
- : InterferenceFunctionItem(Constants::InterferenceFunctionFinite2DLatticeType)
+ : InterferenceFunctionItem("InterferenceFinite2DLattice")
{
setToolTip(QStringLiteral("Interference function of a finite 2D lattice"));
- addGroupProperty(InterferenceFunction2DLatticeItem::P_LATTICE_TYPE, Constants::LatticeGroup)
+ addGroupProperty(InterferenceFunction2DLatticeItem::P_LATTICE_TYPE, "Lattice group")
->setToolTip("Type of lattice");
addProperty(P_XI_INTEGRATION, false)
->setToolTip(QStringLiteral("Enables/disables averaging over the lattice rotation angle."));
@@ -273,7 +273,7 @@ InterferenceFunctionFinite2DLatticeItem::InterferenceFunctionFinite2DLatticeItem
}
});
mapper()->setOnChildPropertyChange([this](SessionItem* item, const QString&) {
- if (item->modelType() == Constants::GroupItemType
+ if (item->modelType() == "GroupProperty"
&& item->displayName() == InterferenceFunction2DLatticeItem::P_LATTICE_TYPE) {
update_rotation_availability();
}
@@ -311,7 +311,7 @@ const QString InterferenceFunctionHardDiskItem::P_DENSITY =
QString::fromStdString("TotalParticleDensity");
InterferenceFunctionHardDiskItem::InterferenceFunctionHardDiskItem()
- : InterferenceFunctionItem(Constants::InterferenceFunctionHardDiskType)
+ : InterferenceFunctionItem("InterferenceHardDisk")
{
setToolTip(QStringLiteral("Interference function for hard disk Percus-Yevick"));
addProperty(P_RADIUS, 5.0 * Units::nanometer)
@@ -342,7 +342,7 @@ const QString InterferenceFunctionRadialParaCrystalItem::P_KAPPA =
const QString InterferenceFunctionRadialParaCrystalItem::P_PDF = "PDF";
InterferenceFunctionRadialParaCrystalItem::InterferenceFunctionRadialParaCrystalItem()
- : InterferenceFunctionItem(Constants::InterferenceFunctionRadialParaCrystalType)
+ : InterferenceFunctionItem("InterferenceRadialParaCrystal")
{
setToolTip(QStringLiteral("Interference function of a radial paracrystal"));
addProperty(P_PEAK_DISTANCE, 20.0 * Units::nanometer)
@@ -356,7 +356,7 @@ InterferenceFunctionRadialParaCrystalItem::InterferenceFunctionRadialParaCrystal
addProperty(P_KAPPA, 0.0)
->setToolTip(QStringLiteral("Size spacing coupling parameter of the Size Spacing "
"Correlation Approximation"));
- addGroupProperty(P_PDF, Constants::FTDistribution1DGroup)
+ addGroupProperty(P_PDF, "PDF 1D")
->setToolTip(QStringLiteral("One-dimensional probability distribution"));
}
diff --git a/GUI/coregui/Models/ItemCatalogue.cpp b/GUI/coregui/Models/ItemCatalogue.cpp
index dd3266e25ce7ca786b402012cd665657409d1a93..26f0014bf073a6fbd2c1af4563240aeecbdfcb9e 100644
--- a/GUI/coregui/Models/ItemCatalogue.cpp
+++ b/GUI/coregui/Models/ItemCatalogue.cpp
@@ -70,185 +70,185 @@ ItemCatalogue::ItemCatalogue()
{
init_top_item_types();
- add(Constants::MultiLayerType, create_new<MultiLayerItem>);
- add(Constants::LayerType, create_new<LayerItem>);
- add(Constants::ParticleLayoutType, create_new<ParticleLayoutItem>);
- add(Constants::ParticleType, create_new<ParticleItem>);
- add(Constants::RotationType, create_new<TransformationItem>);
- add(Constants::ParticleCoreShellType, create_new<ParticleCoreShellItem>);
- add(Constants::ParticleCompositionType, create_new<ParticleCompositionItem>);
- add(Constants::ParticleDistributionType, create_new<ParticleDistributionItem>);
- add(Constants::MesoCrystalType, create_new<MesoCrystalItem>);
- add(Constants::InterferenceFunction1DLatticeType,
+ add("MultiLayer", create_new<MultiLayerItem>);
+ add("Layer", create_new<LayerItem>);
+ add("ParticleLayout", create_new<ParticleLayoutItem>);
+ add("Particle", create_new<ParticleItem>);
+ add("Rotation", create_new<TransformationItem>);
+ add("ParticleCoreShell", create_new<ParticleCoreShellItem>);
+ add("ParticleComposition", create_new<ParticleCompositionItem>);
+ add("ParticleDistribution", create_new<ParticleDistributionItem>);
+ add("MesoCrystal", create_new<MesoCrystalItem>);
+ add("Interference1DLattice",
create_new<InterferenceFunction1DLatticeItem>);
- add(Constants::InterferenceFunction2DLatticeType,
+ add("Interference2DLattice",
create_new<InterferenceFunction2DLatticeItem>);
- add(Constants::InterferenceFunction2DParaCrystalType,
+ add("Interference2DParaCrystal",
create_new<InterferenceFunction2DParaCrystalItem>);
- add(Constants::InterferenceFunctionFinite2DLatticeType,
+ add("InterferenceFinite2DLattice",
create_new<InterferenceFunctionFinite2DLatticeItem>);
- add(Constants::InterferenceFunctionHardDiskType, create_new<InterferenceFunctionHardDiskItem>);
- add(Constants::InterferenceFunctionRadialParaCrystalType,
+ add("InterferenceHardDisk", create_new<InterferenceFunctionHardDiskItem>);
+ add("InterferenceRadialParaCrystal",
create_new<InterferenceFunctionRadialParaCrystalItem>);
- add(Constants::GISASInstrumentType, create_new<GISASInstrumentItem>);
- add(Constants::OffSpecInstrumentType, create_new<OffSpecInstrumentItem>);
- add(Constants::SpecularInstrumentType, create_new<SpecularInstrumentItem>);
- add(Constants::GISASBeamType, create_new<GISASBeamItem>);
- add(Constants::SpecularBeamType, create_new<SpecularBeamItem>);
- add(Constants::BackgroundNoneType, create_new<BackgroundNoneItem>);
- add(Constants::ConstantBackgroundType, create_new<ConstantBackgroundItem>);
- add(Constants::PoissonNoiseBackgroundType, create_new<PoissonNoiseBackgroundItem>);
- add(Constants::FootprintNoneType, create_new<FootprintNoneItem>);
- add(Constants::FootprintGaussianType, create_new<FootprintGaussianItem>);
- add(Constants::FootprintSquareType, create_new<FootprintSquareItem>);
- add(Constants::VectorType, create_new<VectorItem>);
- add(Constants::PropertyType, create_new<PropertyItem>);
-
- add(Constants::AnisoPyramidType, create_new<AnisoPyramidItem>);
- add(Constants::BarGaussType, create_new<BarGaussItem>);
- add(Constants::BarLorentzType, create_new<BarLorentzItem>);
- add(Constants::BoxType, create_new<BoxItem>);
- add(Constants::ConeType, create_new<ConeItem>);
- add(Constants::Cone6Type, create_new<Cone6Item>);
- add(Constants::CuboctahedronType, create_new<CuboctahedronItem>);
- add(Constants::DodecahedronType, create_new<DodecahedronItem>);
- add(Constants::DotType, create_new<DotItem>);
- add(Constants::CylinderType, create_new<CylinderItem>);
- add(Constants::EllipsoidalCylinderType, create_new<EllipsoidalCylinderItem>);
- add(Constants::FullSphereType, create_new<FullSphereItem>);
- add(Constants::FullSpheroidType, create_new<FullSpheroidItem>);
- add(Constants::HemiEllipsoidType, create_new<HemiEllipsoidItem>);
- add(Constants::IcosahedronType, create_new<IcosahedronItem>);
- add(Constants::Prism3Type, create_new<Prism3Item>);
- add(Constants::Prism6Type, create_new<Prism6Item>);
- add(Constants::PyramidType, create_new<PyramidItem>);
- add(Constants::Ripple1BoxType, create_new<Ripple1BoxItem>);
- add(Constants::Ripple1GaussType, create_new<Ripple1GaussItem>);
- add(Constants::Ripple1LorentzType, create_new<Ripple1LorentzItem>);
- add(Constants::Ripple2BoxType, create_new<Ripple2BoxItem>);
- add(Constants::Ripple2GaussType, create_new<Ripple2GaussItem>);
- add(Constants::Ripple2LorentzType, create_new<Ripple2LorentzItem>);
- add(Constants::TetrahedronType, create_new<TetrahedronItem>);
- add(Constants::TruncatedCubeType, create_new<TruncatedCubeItem>);
- add(Constants::TruncatedSphereType, create_new<TruncatedSphereItem>);
- add(Constants::TruncatedSpheroidType, create_new<TruncatedSpheroidItem>);
-
- add(Constants::XRotationType, create_new<XRotationItem>);
- add(Constants::YRotationType, create_new<YRotationItem>);
- add(Constants::ZRotationType, create_new<ZRotationItem>);
- add(Constants::EulerRotationType, create_new<EulerRotationItem>);
-
- add(Constants::LayerBasicRoughnessType, create_new<LayerBasicRoughnessItem>);
- add(Constants::LayerZeroRoughnessType, create_new<LayerZeroRoughnessItem>);
-
- add(Constants::SphericalDetectorType, create_new<SphericalDetectorItem>);
- add(Constants::RectangularDetectorType, create_new<RectangularDetectorItem>);
-
- add(Constants::DistributionNoneType, create_new<DistributionNoneItem>);
- add(Constants::DistributionGateType, create_new<DistributionGateItem>);
- add(Constants::DistributionLorentzType, create_new<DistributionLorentzItem>);
- add(Constants::DistributionGaussianType, create_new<DistributionGaussianItem>);
- add(Constants::DistributionLogNormalType, create_new<DistributionLogNormalItem>);
- add(Constants::DistributionCosineType, create_new<DistributionCosineItem>);
- add(Constants::DistributionTrapezoidType, create_new<DistributionTrapezoidItem>);
-
- add(Constants::FTDistribution1DCauchyType, create_new<FTDistribution1DCauchyItem>);
- add(Constants::FTDistribution1DGaussType, create_new<FTDistribution1DGaussItem>);
- add(Constants::FTDistribution1DGateType, create_new<FTDistribution1DGateItem>);
- add(Constants::FTDistribution1DTriangleType, create_new<FTDistribution1DTriangleItem>);
- add(Constants::FTDistribution1DCosineType, create_new<FTDistribution1DCosineItem>);
- add(Constants::FTDistribution1DVoigtType, create_new<FTDistribution1DVoigtItem>);
-
- add(Constants::FTDistribution2DCauchyType, create_new<FTDistribution2DCauchyItem>);
- add(Constants::FTDistribution2DGaussType, create_new<FTDistribution2DGaussItem>);
- add(Constants::FTDistribution2DGateType, create_new<FTDistribution2DGateItem>);
- add(Constants::FTDistribution2DConeType, create_new<FTDistribution2DConeItem>);
- add(Constants::FTDistribution2DVoigtType, create_new<FTDistribution2DVoigtItem>);
-
- add(Constants::FTDecayFunction1DCauchyType, create_new<FTDecayFunction1DCauchyItem>);
- add(Constants::FTDecayFunction1DGaussType, create_new<FTDecayFunction1DGaussItem>);
- add(Constants::FTDecayFunction1DTriangleType, create_new<FTDecayFunction1DTriangleItem>);
- add(Constants::FTDecayFunction1DVoigtType, create_new<FTDecayFunction1DVoigtItem>);
-
- add(Constants::FTDecayFunction2DCauchyType, create_new<FTDecayFunction2DCauchyItem>);
- add(Constants::FTDecayFunction2DGaussType, create_new<FTDecayFunction2DGaussItem>);
- add(Constants::FTDecayFunction2DVoigtType, create_new<FTDecayFunction2DVoigtItem>);
-
- add(Constants::BasicLatticeType, create_new<BasicLatticeItem>);
- add(Constants::SquareLatticeType, create_new<SquareLatticeItem>);
- add(Constants::HexagonalLatticeType, create_new<HexagonalLatticeItem>);
-
- add(Constants::MaterialType, create_new<MaterialItem>);
- add(Constants::MaterialContainerType, create_new<MaterialItemContainer>);
-
- add(Constants::MaterialRefractiveDataType, create_new<MaterialRefractiveDataItem>);
- add(Constants::MaterialSLDDataType, create_new<MaterialSLDDataItem>);
-
- add(Constants::JobItemType, create_new<JobItem>);
-
- add(Constants::IntensityDataType, create_new<IntensityDataItem>);
- add(Constants::SpecularDataType, create_new<SpecularDataItem>);
- add(Constants::Data1DViewItemType, create_new<Data1DViewItem>);
- add(Constants::DataPropertyContainerType, create_new<DataPropertyContainer>);
- add(Constants::DataItem1DPropertiesType, create_new<Data1DProperties>);
-
- add(Constants::BasicAxisType, create_new<BasicAxisItem>);
- add(Constants::PointwiseAxisType, create_new<PointwiseAxisItem>);
- add(Constants::AmplitudeAxisType, create_new<AmplitudeAxisItem>);
-
- add(Constants::BeamWavelengthType, create_new<BeamWavelengthItem>);
- add(Constants::BeamAzimuthalAngleType, create_new<BeamAzimuthalAngleItem>);
- add(Constants::BeamInclinationAngleType, create_new<BeamInclinationAngleItem>);
- add(Constants::SpecularBeamInclinationType, create_new<SpecularBeamInclinationItem>);
- add(Constants::SpecularBeamWavelengthType, create_new<SpecularBeamWavelengthItem>);
-
- add(Constants::ResolutionFunctionNoneType, create_new<ResolutionFunctionNoneItem>);
- add(Constants::ResolutionFunction2DGaussianType, create_new<ResolutionFunction2DGaussianItem>);
-
- add(Constants::MaskContainerType, create_new<MaskContainerItem>);
- add(Constants::RectangleMaskType, create_new<RectangleItem>);
- add(Constants::PolygonPointType, create_new<PolygonPointItem>);
- add(Constants::PolygonMaskType, create_new<PolygonItem>);
- add(Constants::VerticalLineMaskType, create_new<VerticalLineItem>);
- add(Constants::HorizontalLineMaskType, create_new<HorizontalLineItem>);
- add(Constants::EllipseMaskType, create_new<EllipseItem>);
- add(Constants::MaskAllType, create_new<MaskAllItem>);
-
- add(Constants::RegionOfInterestType, create_new<RegionOfInterestItem>);
-
- add(Constants::GroupItemType, create_new<GroupItem>);
-
- add(Constants::ParameterContainerType, create_new<ParameterContainerItem>);
- add(Constants::ParameterLabelType, create_new<ParameterLabelItem>);
- add(Constants::ParameterType, create_new<ParameterItem>);
-
- add(Constants::FitParameterContainerType, create_new<FitParameterContainerItem>);
- add(Constants::FitParameterType, create_new<FitParameterItem>);
- add(Constants::FitParameterLinkType, create_new<FitParameterLinkItem>);
- add(Constants::FitSuiteType, create_new<FitSuiteItem>);
-
- add(Constants::SimulationOptionsType, create_new<SimulationOptionsItem>);
-
- add(Constants::RealDataType, create_new<RealDataItem>);
-
- add(Constants::MinimizerContainerType, create_new<MinimizerContainerItem>);
- add(Constants::MinuitMinimizerType, create_new<MinuitMinimizerItem>);
- add(Constants::GSLMultiMinimizerType, create_new<GSLMultiMinimizerItem>);
- add(Constants::GeneticMinimizerType, create_new<GeneticMinimizerItem>);
- add(Constants::GSLSimAnMinimizerType, create_new<SimAnMinimizerItem>);
- add(Constants::GSLLMAMinimizerType, create_new<GSLLMAMinimizerItem>);
- add(Constants::TestMinimizerType, create_new<TestMinimizerItem>);
-
- add(Constants::RealLimitsLimitlessType, create_new<LimitlessItem>);
- add(Constants::RealLimitsPositiveType, create_new<PositiveItem>);
- add(Constants::RealLimitsNonnegativeType, create_new<NonnegativeItem>);
- add(Constants::RealLimitsLowerLimitedType, create_new<LowerLimitedItem>);
- add(Constants::RealLimitsUpperLimitedType, create_new<UpperLimitedItem>);
- add(Constants::RealLimitsLimitedType, create_new<LimitedItem>);
-
- add(Constants::ProjectionContainerType, create_new<ProjectionContainerItem>);
-
- add(Constants::DepthProbeInstrumentType, create_new<DepthProbeInstrumentItem>);
+ add("GISASInstrument", create_new<GISASInstrumentItem>);
+ add("OffSpecInstrument", create_new<OffSpecInstrumentItem>);
+ add("SpecularInstrument", create_new<SpecularInstrumentItem>);
+ add("GISASBeam", create_new<GISASBeamItem>);
+ add("SpecularBeam", create_new<SpecularBeamItem>);
+ add("NoBackground", create_new<BackgroundNoneItem>);
+ add("ConstantBackground", create_new<ConstantBackgroundItem>);
+ add("PoissonNoiseBackground", create_new<PoissonNoiseBackgroundItem>);
+ add("NoFootprint", create_new<FootprintNoneItem>);
+ add("GaussianFootrpint", create_new<FootprintGaussianItem>);
+ add("SquareFootprint", create_new<FootprintSquareItem>);
+ add("Vector", create_new<VectorItem>);
+ add("Property", create_new<PropertyItem>);
+
+ add("AnisoPyramid", create_new<AnisoPyramidItem>);
+ add("BarGauss", create_new<BarGaussItem>);
+ add("BarLorentz", create_new<BarLorentzItem>);
+ add("Box", create_new<BoxItem>);
+ add("Cone", create_new<ConeItem>);
+ add("Cone6", create_new<Cone6Item>);
+ add("Cuboctahedron", create_new<CuboctahedronItem>);
+ add("Dodecahedron", create_new<DodecahedronItem>);
+ add("Dot", create_new<DotItem>);
+ add("Cylinder", create_new<CylinderItem>);
+ add("EllipsoidalCylinder", create_new<EllipsoidalCylinderItem>);
+ add("FullSphere", create_new<FullSphereItem>);
+ add("FullSpheroid", create_new<FullSpheroidItem>);
+ add("HemiEllipsoid", create_new<HemiEllipsoidItem>);
+ add("Icosahedron", create_new<IcosahedronItem>);
+ add("Prism3", create_new<Prism3Item>);
+ add("Prism6", create_new<Prism6Item>);
+ add("Pyramid", create_new<PyramidItem>);
+ add("Ripple1Box", create_new<Ripple1BoxItem>);
+ add("Ripple1Gauss", create_new<Ripple1GaussItem>);
+ add("Ripple1Lorentz", create_new<Ripple1LorentzItem>);
+ add("Ripple2Box", create_new<Ripple2BoxItem>);
+ add("Ripple2Gauss", create_new<Ripple2GaussItem>);
+ add("Ripple2Lorentz", create_new<Ripple2LorentzItem>);
+ add("Tetrahedron", create_new<TetrahedronItem>);
+ add("TruncatedCube", create_new<TruncatedCubeItem>);
+ add("TruncatedSphere", create_new<TruncatedSphereItem>);
+ add("TruncatedSpheroid", create_new<TruncatedSpheroidItem>);
+
+ add("XRotation", create_new<XRotationItem>);
+ add("YRotation", create_new<YRotationItem>);
+ add("ZRotation", create_new<ZRotationItem>);
+ add("EulerRotation", create_new<EulerRotationItem>);
+
+ add("LayerBasicRoughness", create_new<LayerBasicRoughnessItem>);
+ add("LayerZeroRoughness", create_new<LayerZeroRoughnessItem>);
+
+ add("SphericalDetector", create_new<SphericalDetectorItem>);
+ add("RectangularDetector", create_new<RectangularDetectorItem>);
+
+ add("DistributionNone", create_new<DistributionNoneItem>);
+ add("DistributionGate", create_new<DistributionGateItem>);
+ add("DistributionLorentz", create_new<DistributionLorentzItem>);
+ add("DistributionGaussian", create_new<DistributionGaussianItem>);
+ add("DistributionLogNormal", create_new<DistributionLogNormalItem>);
+ add("DistributionCosine", create_new<DistributionCosineItem>);
+ add("DistributionTrapezoid", create_new<DistributionTrapezoidItem>);
+
+ add("FTDistribution1DCauchy", create_new<FTDistribution1DCauchyItem>);
+ add("FTDistribution1DGauss", create_new<FTDistribution1DGaussItem>);
+ add("FTDistribution1DGate", create_new<FTDistribution1DGateItem>);
+ add("FTDistribution1DTriangle", create_new<FTDistribution1DTriangleItem>);
+ add("FTDistribution1DCosine", create_new<FTDistribution1DCosineItem>);
+ add("FTDistribution1DVoigt", create_new<FTDistribution1DVoigtItem>);
+
+ add("FTDistribution2DCauchy", create_new<FTDistribution2DCauchyItem>);
+ add("FTDistribution2DGauss", create_new<FTDistribution2DGaussItem>);
+ add("FTDistribution2DGate", create_new<FTDistribution2DGateItem>);
+ add("FTDistribution2DCone", create_new<FTDistribution2DConeItem>);
+ add("FTDistribution2DVoigt", create_new<FTDistribution2DVoigtItem>);
+
+ add("FTDecayFunction1DCauchy", create_new<FTDecayFunction1DCauchyItem>);
+ add("FTDecayFunction1DGauss", create_new<FTDecayFunction1DGaussItem>);
+ add("FTDecayFunction1DTriangle", create_new<FTDecayFunction1DTriangleItem>);
+ add("FTDecayFunction1DVoigt", create_new<FTDecayFunction1DVoigtItem>);
+
+ add("FTDecayFunction2DCauchy", create_new<FTDecayFunction2DCauchyItem>);
+ add("FTDecayFunction2DGauss", create_new<FTDecayFunction2DGaussItem>);
+ add("FTDecayFunction2DVoigt", create_new<FTDecayFunction2DVoigtItem>);
+
+ add("BasicLattice", create_new<BasicLatticeItem>);
+ add("SquareLattice", create_new<SquareLatticeItem>);
+ add("HexagonalLattice", create_new<HexagonalLatticeItem>);
+
+ add("Material", create_new<MaterialItem>);
+ add("MaterialContainer", create_new<MaterialItemContainer>);
+
+ add("MaterialRefractiveData", create_new<MaterialRefractiveDataItem>);
+ add("MaterialSLDData", create_new<MaterialSLDDataItem>);
+
+ add("JobItem", create_new<JobItem>);
+
+ add("IntensityData", create_new<IntensityDataItem>);
+ add("SpecularData", create_new<SpecularDataItem>);
+ add("Data1DViewItem", create_new<Data1DViewItem>);
+ add("DataPropertyContainer", create_new<DataPropertyContainer>);
+ add("DataItem1DProperties", create_new<Data1DProperties>);
+
+ add("BasicAxis", create_new<BasicAxisItem>);
+ add("PointwiseAxis", create_new<PointwiseAxisItem>);
+ add("AmplitudeAxis", create_new<AmplitudeAxisItem>);
+
+ add("BeamWavelength", create_new<BeamWavelengthItem>);
+ add("BeamAzimuthalAngle", create_new<BeamAzimuthalAngleItem>);
+ add("BeamInclinationAngle", create_new<BeamInclinationAngleItem>);
+ add("SpecularBeamInclinationAxis", create_new<SpecularBeamInclinationItem>);
+ add("SpecularBeamWavelength", create_new<SpecularBeamWavelengthItem>);
+
+ add("ResolutionFunctionNone", create_new<ResolutionFunctionNoneItem>);
+ add("ResolutionFunction2DGaussian", create_new<ResolutionFunction2DGaussianItem>);
+
+ add("MaskContainer", create_new<MaskContainerItem>);
+ add("RectangleMask", create_new<RectangleItem>);
+ add("PolygonPoint", create_new<PolygonPointItem>);
+ add("PolygonMask", create_new<PolygonItem>);
+ add("VerticalLineMask", create_new<VerticalLineItem>);
+ add("HorizontalLineMask", create_new<HorizontalLineItem>);
+ add("EllipseMask", create_new<EllipseItem>);
+ add("MaskAllMask", create_new<MaskAllItem>);
+
+ add("RegionOfInterest", create_new<RegionOfInterestItem>);
+
+ add("GroupProperty", create_new<GroupItem>);
+
+ add("Parameter Container", create_new<ParameterContainerItem>);
+ add("Parameter Label", create_new<ParameterLabelItem>);
+ add("Parameter", create_new<ParameterItem>);
+
+ add("FitParameterContainer", create_new<FitParameterContainerItem>);
+ add("FitParameter", create_new<FitParameterItem>);
+ add("FitParameterLink", create_new<FitParameterLinkItem>);
+ add("FitSuite", create_new<FitSuiteItem>);
+
+ add("SimulationOptions", create_new<SimulationOptionsItem>);
+
+ add("RealData", create_new<RealDataItem>);
+
+ add("MinimizerContainer", create_new<MinimizerContainerItem>);
+ add("Minuit2", create_new<MinuitMinimizerItem>);
+ add("GSLMultiMin", create_new<GSLMultiMinimizerItem>);
+ add("Genetic", create_new<GeneticMinimizerItem>);
+ add("GSLSimAn", create_new<SimAnMinimizerItem>);
+ add("GSLLMA", create_new<GSLLMAMinimizerItem>);
+ add("Test", create_new<TestMinimizerItem>);
+
+ add("RealLimitsLimitless", create_new<LimitlessItem>);
+ add("RealLimitsPositive", create_new<PositiveItem>);
+ add("RealLimitsNonnegative", create_new<NonnegativeItem>);
+ add("RealLimitsLowerLimited", create_new<LowerLimitedItem>);
+ add("RealLimitsUpperLimited", create_new<UpperLimitedItem>);
+ add("RealLimitsLimited", create_new<LimitedItem>);
+
+ add("ProjectionContainer", create_new<ProjectionContainerItem>);
+
+ add("DepthProbeInstrument", create_new<DepthProbeInstrumentItem>);
}
bool ItemCatalogue::contains(const QString& modelType) const
@@ -275,15 +275,15 @@ void ItemCatalogue::init_top_item_types()
{
m_valid_top_item_types.clear();
- m_valid_top_item_types << Constants::MultiLayerType << Constants::LayerType
- << Constants::ParticleLayoutType << Constants::ParticleType
- << Constants::ParticleCoreShellType << Constants::ParticleCompositionType
- << Constants::MesoCrystalType << Constants::ParticleDistributionType
- << Constants::RotationType
- << Constants::InterferenceFunction1DLatticeType
- << Constants::InterferenceFunction2DLatticeType
- << Constants::InterferenceFunction2DParaCrystalType
- << Constants::InterferenceFunctionFinite2DLatticeType
- << Constants::InterferenceFunctionHardDiskType
- << Constants::InterferenceFunctionRadialParaCrystalType;
+ m_valid_top_item_types << "MultiLayer" << "Layer"
+ << "ParticleLayout" << "Particle"
+ << "ParticleCoreShell" << "ParticleComposition"
+ << "MesoCrystal" << "ParticleDistribution"
+ << "Rotation"
+ << "Interference1DLattice"
+ << "Interference2DLattice"
+ << "Interference2DParaCrystal"
+ << "InterferenceFinite2DLattice"
+ << "InterferenceHardDisk"
+ << "InterferenceRadialParaCrystal";
}
diff --git a/GUI/coregui/Models/ItemFactory.cpp b/GUI/coregui/Models/ItemFactory.cpp
index 2f40e1e8edd50dc353c52eaa38935243a2a455dc..46088733099bad7c05b43e6ee6dd527f71f568c0 100644
--- a/GUI/coregui/Models/ItemFactory.cpp
+++ b/GUI/coregui/Models/ItemFactory.cpp
@@ -43,7 +43,7 @@ SessionItem* ItemFactory::CreateItem(const QString& model_name, SessionItem* par
SessionItem* ItemFactory::CreateEmptyItem()
{
- return new SessionItem(Constants::RootItemType);
+ return new SessionItem("ROOT_ITEM");
}
QStringList ItemFactory::ValidTopItemTypes()
diff --git a/GUI/coregui/Models/ItemFileNameUtils.cpp b/GUI/coregui/Models/ItemFileNameUtils.cpp
index d71e1b203c3ae37c6a18fdae8a6daa1580f2882a..fdddd789010ff571597c7fa13f2f7d65b434bca3 100644
--- a/GUI/coregui/Models/ItemFileNameUtils.cpp
+++ b/GUI/coregui/Models/ItemFileNameUtils.cpp
@@ -16,7 +16,6 @@
#include "GUI/coregui/Models/InstrumentItems.h"
#include "GUI/coregui/Models/JobItem.h"
#include "GUI/coregui/Models/RealDataItem.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/utils/GUIHelpers.h"
namespace
diff --git a/GUI/coregui/Models/JobItem.cpp b/GUI/coregui/Models/JobItem.cpp
index 1110a7860f9fee0a9cbb6366014511feb6cd0be9..da90860e0247bb1d20ce280d3f689293fdb69212 100644
--- a/GUI/coregui/Models/JobItem.cpp
+++ b/GUI/coregui/Models/JobItem.cpp
@@ -26,7 +26,6 @@
#include "GUI/coregui/Models/RealDataItem.h"
#include "GUI/coregui/Models/SimulationOptionsItem.h"
#include "GUI/coregui/Models/SpecularDataItem.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/MaskWidgets/MaskUnitsConverter.h"
#include "GUI/coregui/utils/GUIHelpers.h"
@@ -51,15 +50,15 @@ const QString JobItem::T_PARAMETER_TREE = "Parameter Tree";
const QString JobItem::T_SIMULATION_OPTIONS = "Simulation Options";
const QString JobItem::T_FIT_SUITE = "Fit Suite";
-JobItem::JobItem() : SessionItem(Constants::JobItemType)
+JobItem::JobItem() : SessionItem("JobItem")
{
- setItemName(Constants::JobItemType);
+ setItemName("JobItem");
addProperty(P_IDENTIFIER, QString())->setVisible(false);
addProperty(P_SAMPLE_NAME, QString())->setEditable(false);
addProperty(P_INSTRUMENT_NAME, QString())->setEditable(false);
addProperty(P_WITH_FITTING, false)->setVisible(false);
- addProperty(P_STATUS, Constants::STATUS_IDLE)->setEditable(false);
+ addProperty(P_STATUS, "Idle")->setEditable(false);
addProperty(P_BEGIN_TIME, QString())->setEditable(false);
addProperty(P_END_TIME, QString())->setEditable(false);
@@ -72,21 +71,21 @@ JobItem::JobItem() : SessionItem(Constants::JobItemType)
addProperty(P_PROGRESS, 0)->setVisible(false);
addProperty(P_PRESENTATION_TYPE, QVariant::Type::Invalid)->setVisible(false);
- registerTag(T_SAMPLE, 1, 1, QStringList() << Constants::MultiLayerType);
- registerTag(T_MATERIAL_CONTAINER, 1, 1, QStringList{Constants::MaterialContainerType});
+ registerTag(T_SAMPLE, 1, 1, QStringList() << "MultiLayer");
+ registerTag(T_MATERIAL_CONTAINER, 1, 1, QStringList{"MaterialContainer"});
registerTag(T_INSTRUMENT, 1, 1,
- QStringList() << Constants::GISASInstrumentType << Constants::OffSpecInstrumentType
- << Constants::SpecularInstrumentType
- << Constants::DepthProbeInstrumentType);
+ QStringList() << "GISASInstrument" << "OffSpecInstrument"
+ << "SpecularInstrument"
+ << "DepthProbeInstrument");
registerTag(T_OUTPUT, 1, 1,
- QStringList() << Constants::IntensityDataType << Constants::SpecularDataType);
- registerTag(T_REALDATA, 1, 1, QStringList() << Constants::RealDataType);
- registerTag(T_DATAVIEW, 1, 1, QStringList() << Constants::Data1DViewItemType);
- registerTag(T_PARAMETER_TREE, 0, -1, QStringList() << Constants::ParameterContainerType);
+ QStringList() << "IntensityData" << "SpecularData");
+ registerTag(T_REALDATA, 1, 1, QStringList() << "RealData");
+ registerTag(T_DATAVIEW, 1, 1, QStringList() << "Data1DViewItem");
+ registerTag(T_PARAMETER_TREE, 0, -1, QStringList() << "Parameter Container");
- registerTag(T_SIMULATION_OPTIONS, 1, 1, QStringList() << Constants::SimulationOptionsType);
+ registerTag(T_SIMULATION_OPTIONS, 1, 1, QStringList() << "SimulationOptions");
- registerTag(T_FIT_SUITE, 1, 1, QStringList() << Constants::FitSuiteType);
+ registerTag(T_FIT_SUITE, 1, 1, QStringList() << "FitSuite");
mapper()->setOnChildPropertyChange([this](SessionItem* item, const QString& name) {
if (item->parent() == this && dynamic_cast<DataItem*>(item)
@@ -128,7 +127,7 @@ QString JobItem::getStatus() const
void JobItem::setStatus(const QString& status)
{
setItemValue(P_STATUS, status);
- if (status == Constants::STATUS_FAILED) {
+ if (status == "Failed") {
if (DataItem* intensityItem = dataItem()) {
if (intensityItem->getOutputData())
intensityItem->getOutputData()->setAllTo(0.0);
@@ -139,27 +138,27 @@ void JobItem::setStatus(const QString& status)
bool JobItem::isIdle() const
{
- return getStatus() == Constants::STATUS_IDLE;
+ return getStatus() == "Idle";
}
bool JobItem::isRunning() const
{
- return getStatus() == Constants::STATUS_RUNNING;
+ return getStatus() == "Running";
}
bool JobItem::isCompleted() const
{
- return getStatus() == Constants::STATUS_COMPLETED;
+ return getStatus() == "Completed";
}
bool JobItem::isCanceled() const
{
- return getStatus() == Constants::STATUS_CANCELED;
+ return getStatus() == "Canceled";
}
bool JobItem::isFailed() const
{
- return getStatus() == Constants::STATUS_FAILED;
+ return getStatus() == "Failed";
}
bool JobItem::isValidForFitting()
diff --git a/GUI/coregui/Models/JobItemUtils.cpp b/GUI/coregui/Models/JobItemUtils.cpp
index b8c6421a047892405b282c3d34a024fd7ed084a2..8bea5605ed3173dccf262078da5d952a15037b3d 100644
--- a/GUI/coregui/Models/JobItemUtils.cpp
+++ b/GUI/coregui/Models/JobItemUtils.cpp
@@ -27,17 +27,17 @@
namespace
{
-const std::map<QString, AxesUnits> units_from_names{{Constants::UnitsNbins, AxesUnits::NBINS},
- {Constants::UnitsRadians, AxesUnits::RADIANS},
- {Constants::UnitsDegrees, AxesUnits::DEGREES},
- {Constants::UnitsMm, AxesUnits::MM},
- {Constants::UnitsQyQz, AxesUnits::QSPACE}};
-
-const std::map<AxesUnits, QString> names_from_units{{AxesUnits::NBINS, Constants::UnitsNbins},
- {AxesUnits::RADIANS, Constants::UnitsRadians},
- {AxesUnits::MM, Constants::UnitsMm},
- {AxesUnits::QSPACE, Constants::UnitsQyQz},
- {AxesUnits::DEGREES, Constants::UnitsDegrees}};
+const std::map<QString, AxesUnits> units_from_names{{"nbins", AxesUnits::NBINS},
+ {"Radians", AxesUnits::RADIANS},
+ {"Degrees", AxesUnits::DEGREES},
+ {"mm", AxesUnits::MM},
+ {"q-space", AxesUnits::QSPACE}};
+
+const std::map<AxesUnits, QString> names_from_units{{AxesUnits::NBINS, "nbins"},
+ {AxesUnits::RADIANS, "Radians"},
+ {AxesUnits::MM, "mm"},
+ {AxesUnits::QSPACE, "q-space"},
+ {AxesUnits::DEGREES, "Degrees"}};
//! Updates axes' titles
void updateAxesTitle(DataItem* intensityItem, const IUnitConverter& converter, AxesUnits units);
diff --git a/GUI/coregui/Models/JobModel.cpp b/GUI/coregui/Models/JobModel.cpp
index 90491e760f5aec679b9bf71043f4da6b979009e8..1d1b8799d86b5df42fe959d1461d66b39f2efc7f 100644
--- a/GUI/coregui/Models/JobModel.cpp
+++ b/GUI/coregui/Models/JobModel.cpp
@@ -78,7 +78,7 @@ JobItem* JobModel::addJob(const MultiLayerItem* multiLayerItem,
Q_ASSERT(instrumentItem);
Q_ASSERT(optionItem);
- JobItem* jobItem = dynamic_cast<JobItem*>(insertNewItem(Constants::JobItemType));
+ JobItem* jobItem = dynamic_cast<JobItem*>(insertNewItem("JobItem"));
jobItem->setItemName(generateJobName());
jobItem->setIdentifier(GUIHelpers::createUuid());
@@ -86,7 +86,7 @@ JobItem* JobModel::addJob(const MultiLayerItem* multiLayerItem,
JobModelFunctions::setupJobItemInstrument(jobItem, instrumentItem);
// TODO: remove when specular instrument is ready for magnetization
- if (instrumentItem->modelType() == Constants::SpecularInstrumentType)
+ if (instrumentItem->modelType() == "SpecularInstrument")
JobModelFunctions::muteMagnetizationData(jobItem);
copyItem(optionItem, jobItem, JobItem::T_SIMULATION_OPTIONS);
@@ -112,7 +112,7 @@ bool JobModel::hasUnfinishedJobs()
{
bool result = m_queue_data->hasUnfinishedJobs();
for (auto jobItem : topItems<JobItem>()) {
- if (jobItem->getStatus() == Constants::STATUS_FITTING)
+ if (jobItem->getStatus() == "Fitting")
result = true;
}
@@ -146,7 +146,7 @@ QVector<SessionItem*> JobModel::nonXMLData() const
dynamic_cast<SpecularInstrumentItem*>(jobItem->getItem(JobItem::T_INSTRUMENT));
if (instrument) {
auto axis_group = instrument->beamItem()->inclinationAxisGroup();
- result.push_back(axis_group->getChildOfType(Constants::PointwiseAxisType));
+ result.push_back(axis_group->getChildOfType("PointwiseAxis"));
}
}
@@ -198,7 +198,7 @@ QString JobModel::generateJobName()
QModelIndex itemIndex = index(i_row, 0, parentIndex);
if (SessionItem* item = itemForIndex(itemIndex)) {
- if (item->modelType() == Constants::JobItemType) {
+ if (item->modelType() == "JobItem") {
QString jobName = item->itemName();
if (jobName.startsWith("job")) {
int job_index = jobName.remove(0, 3).toInt();
diff --git a/GUI/coregui/Models/JobModelFunctions.cpp b/GUI/coregui/Models/JobModelFunctions.cpp
index b586e88b30d6f8fbfe61337ca729726f302fe7ed..61e56a6b9371936a28ff48ca6b0117165a14788c 100644
--- a/GUI/coregui/Models/JobModelFunctions.cpp
+++ b/GUI/coregui/Models/JobModelFunctions.cpp
@@ -63,16 +63,16 @@ void JobModelFunctions::initDataView(JobItem* job_item)
{
assert(job_item && job_item->isValidForFitting());
assert(job_item->instrumentItem()
- && job_item->instrumentItem()->modelType() == Constants::SpecularInstrumentType);
+ && job_item->instrumentItem()->modelType() == "SpecularInstrument");
assert(!job_item->getItem(JobItem::T_DATAVIEW));
SessionModel* model = job_item->model();
auto view_item = dynamic_cast<Data1DViewItem*>(model->insertNewItem(
- Constants::Data1DViewItemType, job_item->index(), -1, JobItem::T_DATAVIEW));
+ "Data1DViewItem", job_item->index(), -1, JobItem::T_DATAVIEW));
assert(view_item);
auto property_container = dynamic_cast<DataPropertyContainer*>(
- model->insertNewItem(Constants::DataPropertyContainerType, view_item->index(), -1,
+ model->insertNewItem("DataPropertyContainer", view_item->index(), -1,
Data1DViewItem::T_DATA_PROPERTIES));
assert(property_container);
@@ -91,11 +91,11 @@ void JobModelFunctions::setupJobItemSampleData(JobItem* jobItem, const MultiLaye
auto model = jobItem->model();
MultiLayerItem* multilayer =
static_cast<MultiLayerItem*>(model->copyItem(sampleItem, jobItem, JobItem::T_SAMPLE));
- multilayer->setItemName(Constants::MultiLayerType);
+ multilayer->setItemName("MultiLayer");
// copying materials
auto container = static_cast<MaterialItemContainer*>(jobItem->model()->insertNewItem(
- Constants::MaterialContainerType, jobItem->index(), -1, JobItem::T_MATERIAL_CONTAINER));
+ "MaterialContainer", jobItem->index(), -1, JobItem::T_MATERIAL_CONTAINER));
std::map<MaterialItem*, QString> materials;
for (auto property_item : multilayer->materialPropertyItems()) {
@@ -133,7 +133,7 @@ void JobModelFunctions::setupJobItemInstrument(JobItem* jobItem, const Instrumen
auto spec_from = static_cast<const SpecularInstrumentItem*>(from);
auto axis_origin = getPointwiseAxisItem(spec_from);
const QString current_axis_type = spec_from->beamItem()->inclinationAxisGroup()->currentType();
- if (current_axis_type == Constants::PointwiseAxisType)
+ if (current_axis_type == "PointwiseAxis")
spec_to->beamItem()->updateToData(*axis_origin->getAxis(), axis_origin->getUnitsLabel());
else if (axis_origin->containsNonXMLData())
getPointwiseAxisItem(spec_to)->init(*axis_origin->getAxis(), axis_origin->getUnitsLabel());
@@ -146,14 +146,14 @@ void JobModelFunctions::setupJobItemOutput(JobItem* jobItem)
auto model = jobItem->model();
auto instrumentType = jobItem->instrumentItem()->modelType();
- if (instrumentType == Constants::SpecularInstrumentType) {
- model->insertNewItem(Constants::SpecularDataType, model->indexOfItem(jobItem), -1,
+ if (instrumentType == "SpecularInstrument") {
+ model->insertNewItem("SpecularData", model->indexOfItem(jobItem), -1,
JobItem::T_OUTPUT);
- } else if (instrumentType == Constants::GISASInstrumentType
- || instrumentType == Constants::OffSpecInstrumentType
- || instrumentType == Constants::DepthProbeInstrumentType) {
- model->insertNewItem(Constants::IntensityDataType, model->indexOfItem(jobItem), -1,
+ } else if (instrumentType == "GISASInstrument"
+ || instrumentType == "OffSpecInstrument"
+ || instrumentType == "DepthProbeInstrument") {
+ model->insertNewItem("IntensityData", model->indexOfItem(jobItem), -1,
JobItem::T_OUTPUT);
} else {
@@ -175,9 +175,9 @@ void JobModelFunctions::setupJobItemForFit(JobItem* jobItem, const RealDataItem*
copyMasksToInstrument(jobItem);
// TODO: remove if when other simulation types are ready for roi & masks
- if (jobItem->instrumentItem()->modelType() == Constants::GISASInstrumentType)
+ if (jobItem->instrumentItem()->modelType() == "GISASInstrument")
cropRealData(jobItem);
- if (jobItem->instrumentItem()->modelType() == Constants::SpecularInstrumentType)
+ if (jobItem->instrumentItem()->modelType() == "SpecularInstrument")
initDataView(jobItem);
createFitContainers(jobItem);
@@ -222,7 +222,7 @@ void JobModelFunctions::copyRealDataItem(JobItem* jobItem, const RealDataItem* r
const JobItem* JobModelFunctions::findJobItem(const SessionItem* item)
{
- while (item && item->modelType() != Constants::JobItemType)
+ while (item && item->modelType() != "JobItem")
item = item->parent();
return static_cast<const JobItem*>(item);
}
@@ -277,7 +277,7 @@ void createFitContainers(JobItem* jobItem)
}
fitSuiteItem =
- model->insertNewItem(Constants::FitSuiteType, jobItem->index(), -1, JobItem::T_FIT_SUITE);
+ model->insertNewItem("FitSuite", jobItem->index(), -1, JobItem::T_FIT_SUITE);
SessionItem* parsContainerItem = fitSuiteItem->getItem(FitSuiteItem::T_FIT_PARAMETERS);
if (parsContainerItem != nullptr) {
@@ -286,7 +286,7 @@ void createFitContainers(JobItem* jobItem)
}
parsContainerItem =
- model->insertNewItem(Constants::FitParameterContainerType, fitSuiteItem->index(), -1,
+ model->insertNewItem("FitParameterContainer", fitSuiteItem->index(), -1,
FitSuiteItem::T_FIT_PARAMETERS);
// Minimizer settings
@@ -297,13 +297,13 @@ void createFitContainers(JobItem* jobItem)
}
minimizerContainerItem = model->insertNewItem(
- Constants::MinimizerContainerType, fitSuiteItem->index(), -1, FitSuiteItem::T_MINIMIZER);
+ "MinimizerContainer", fitSuiteItem->index(), -1, FitSuiteItem::T_MINIMIZER);
}
PointwiseAxisItem* getPointwiseAxisItem(const SpecularInstrumentItem* instrument)
{
return dynamic_cast<PointwiseAxisItem*>(
instrument->beamItem()->inclinationAxisGroup()->getChildOfType(
- Constants::PointwiseAxisType));
+ "PointwiseAxis"));
}
} // namespace
diff --git a/GUI/coregui/Models/JobQueueData.cpp b/GUI/coregui/Models/JobQueueData.cpp
index 41a795b8ac6fc188920aa1dfd0f95e816bff5733..34a1ff31c534fb2c8b92a0adf5792032a7b0bbb8 100644
--- a/GUI/coregui/Models/JobQueueData.cpp
+++ b/GUI/coregui/Models/JobQueueData.cpp
@@ -56,7 +56,7 @@ void JobQueueData::runJob(JobItem* jobItem)
message += QString::fromStdString(std::string(ex.what()));
jobItem->setComments(message);
jobItem->setProgress(100);
- jobItem->setStatus(Constants::STATUS_FAILED);
+ jobItem->setStatus("Failed");
emit focusRequest(jobItem);
return;
}
@@ -108,7 +108,7 @@ void JobQueueData::onStartedJob()
auto jobItem = m_jobModel->getJobItemForIdentifier(worker->identifier());
jobItem->setProgress(0);
- jobItem->setStatus(Constants::STATUS_RUNNING);
+ jobItem->setStatus("Running");
jobItem->setBeginTime(GUIHelpers::currentDateTime());
jobItem->setEndTime(QString());
}
@@ -229,7 +229,7 @@ void JobQueueData::processFinishedJob(JobWorker* worker, JobItem* jobItem)
jobItem->setDuration(worker->simulationDuration());
// propagating status of runner
- if (worker->status() == Constants::STATUS_FAILED) {
+ if (worker->status() == "Failed") {
jobItem->setComments(worker->failureMessage());
} else {
// propagating simulation results
diff --git a/GUI/coregui/Models/JobWorker.cpp b/GUI/coregui/Models/JobWorker.cpp
index f349558f5567369be6740f61404885d15cc68933..7e450ba4e45565a811162d79ecafa983d024be5d 100644
--- a/GUI/coregui/Models/JobWorker.cpp
+++ b/GUI/coregui/Models/JobWorker.cpp
@@ -14,13 +14,12 @@
#include "GUI/coregui/Models/JobWorker.h"
#include "Core/Simulation/GISASSimulation.h"
-#include "GUI/coregui/Models/item_constants.h"
#include <QDateTime>
#include <memory>
JobWorker::JobWorker(const QString& identifier, Simulation* simulation)
: m_identifier(identifier), m_simulation(simulation), m_percentage_done(0),
- m_job_status(Constants::STATUS_IDLE), m_terminate_request_flag(false),
+ m_job_status("Idle"), m_terminate_request_flag(false),
m_simulation_duration(0)
{
}
@@ -46,19 +45,19 @@ void JobWorker::start()
return updateProgress(static_cast<int>(percentage_done));
});
- m_job_status = Constants::STATUS_RUNNING;
+ m_job_status = "Running";
try {
QDateTime beginTime = QDateTime::currentDateTime();
m_simulation->runSimulation();
- if (m_job_status != Constants::STATUS_CANCELED)
- m_job_status = Constants::STATUS_COMPLETED;
+ if (m_job_status != "Canceled")
+ m_job_status = "Completed";
QDateTime endTime = QDateTime::currentDateTime();
m_simulation_duration = static_cast<int>(beginTime.msecsTo(endTime));
} catch (const std::exception& ex) {
- m_job_status = Constants::STATUS_FAILED;
+ m_job_status = "Failed";
m_percentage_done = 100;
m_failure_message =
QString("JobRunner::start() -> Simulation failed with exception throw:\n\n");
@@ -67,7 +66,7 @@ void JobWorker::start()
}
} else {
- m_job_status = Constants::STATUS_FAILED;
+ m_job_status = "Failed";
m_percentage_done = 100;
m_failure_message = QString("JobRunner::start() -> Error. Simulation doesn't exist.");
}
@@ -96,7 +95,7 @@ int JobWorker::simulationDuration() const
void JobWorker::terminate()
{
m_terminate_request_flag = true;
- m_job_status = Constants::STATUS_CANCELED;
+ m_job_status = "Canceled";
}
//! Sets current progress. Returns true if we want to continue the simulation.
diff --git a/GUI/coregui/Models/Lattice2DItems.cpp b/GUI/coregui/Models/Lattice2DItems.cpp
index 5c5e752ccfebf90a0ec77f7ca645ee799e0d3249..76f7e5df6889ab86e348d038eaee574e139d147e 100644
--- a/GUI/coregui/Models/Lattice2DItems.cpp
+++ b/GUI/coregui/Models/Lattice2DItems.cpp
@@ -36,7 +36,7 @@ const QString BasicLatticeItem::P_LATTICE_LENGTH1 = QString::fromStdString("Latt
const QString BasicLatticeItem::P_LATTICE_LENGTH2 = QString::fromStdString("LatticeLength2");
const QString BasicLatticeItem::P_LATTICE_ANGLE = QString::fromStdString("Alpha");
-BasicLatticeItem::BasicLatticeItem() : Lattice2DItem(Constants::BasicLatticeType)
+BasicLatticeItem::BasicLatticeItem() : Lattice2DItem("BasicLattice")
{
setToolTip(QStringLiteral("Two dimensional lattice"));
addProperty(P_LATTICE_LENGTH1, 20.0)
@@ -60,7 +60,7 @@ std::unique_ptr<Lattice2D> BasicLatticeItem::createLattice() const
const QString SquareLatticeItem::P_LATTICE_LENGTH = QString::fromStdString("LatticeLength");
-SquareLatticeItem::SquareLatticeItem() : Lattice2DItem(Constants::SquareLatticeType)
+SquareLatticeItem::SquareLatticeItem() : Lattice2DItem("SquareLattice")
{
addProperty(P_LATTICE_LENGTH, 20.0)
->setToolTip(QStringLiteral("Length of first and second lattice vectors in nanometers"));
@@ -78,7 +78,7 @@ std::unique_ptr<Lattice2D> SquareLatticeItem::createLattice() const
const QString HexagonalLatticeItem::P_LATTICE_LENGTH = QString::fromStdString("LatticeLength");
-HexagonalLatticeItem::HexagonalLatticeItem() : Lattice2DItem(Constants::HexagonalLatticeType)
+HexagonalLatticeItem::HexagonalLatticeItem() : Lattice2DItem("HexagonalLattice")
{
addProperty(P_LATTICE_LENGTH, 20.0)
->setToolTip(QStringLiteral("Length of first and second lattice vectors in nanometers"));
diff --git a/GUI/coregui/Models/LayerItem.cpp b/GUI/coregui/Models/LayerItem.cpp
index da81ffb9a63f479a26805efd50c9a3cbd1b8666a..22b2a3f39154b0aa722bb2091960e797d6b72a43 100644
--- a/GUI/coregui/Models/LayerItem.cpp
+++ b/GUI/coregui/Models/LayerItem.cpp
@@ -28,7 +28,7 @@ const QString LayerItem::P_MATERIAL = "Material";
const QString LayerItem::P_NSLICES = "Number of slices";
const QString LayerItem::T_LAYOUTS = "Layout tag";
-LayerItem::LayerItem() : SessionGraphicsItem(Constants::LayerType)
+LayerItem::LayerItem() : SessionGraphicsItem("Layer")
{
setToolTip(QStringLiteral("A layer with thickness and material"));
addProperty(P_THICKNESS, 0.0)
@@ -37,16 +37,16 @@ LayerItem::LayerItem() : SessionGraphicsItem(Constants::LayerType)
addProperty(P_MATERIAL, MaterialItemUtils::defaultMaterialProperty().variant())
->setToolTip(QStringLiteral("Material the layer is made of"))
- .setEditorType(Constants::MaterialEditorExternalType);
+ .setEditorType("ExtMaterialEditor");
addProperty(P_NSLICES, 1)
->setLimits(RealLimits::lowerLimited(0.0))
.setToolTip(layer_nslices_tooltip);
- addGroupProperty(P_ROUGHNESS, Constants::LayerRoughnessGroup)
+ addGroupProperty(P_ROUGHNESS, "Roughness")
->setToolTip(QStringLiteral("Roughness of top interface"));
- registerTag(T_LAYOUTS, 0, -1, QStringList() << Constants::ParticleLayoutType);
+ registerTag(T_LAYOUTS, 0, -1, QStringList() << "ParticleLayout");
setDefaultTag(T_LAYOUTS);
mapper()->setOnParentChange([this](SessionItem* new_parent) { updateAppearance(new_parent); });
@@ -65,7 +65,7 @@ QVector<SessionItem*> LayerItem::materialPropertyItems()
void LayerItem::updateAppearance(SessionItem* new_parent)
{
if (!new_parent) {
- if (parent() && parent()->modelType() == Constants::MultiLayerType) {
+ if (parent() && parent()->modelType() == "MultiLayer") {
// we are about to be removed from MultiLayer
getItem(LayerItem::P_ROUGHNESS)->setEnabled(true);
getItem(LayerItem::P_THICKNESS)->setEnabled(true);
diff --git a/GUI/coregui/Models/LayerRoughnessItems.cpp b/GUI/coregui/Models/LayerRoughnessItems.cpp
index d764ec44a019cc1715b896c0db94de97b281143b..14f3b5c2e3aceaf98ec59d59a4bcf16b39ec703b 100644
--- a/GUI/coregui/Models/LayerRoughnessItems.cpp
+++ b/GUI/coregui/Models/LayerRoughnessItems.cpp
@@ -21,14 +21,14 @@ const QString hurst_tooltip =
"dimensionless [0.0, 1.0], where 0.0 gives more spikes, \n1.0 more smoothness.";
}
-LayerZeroRoughnessItem::LayerZeroRoughnessItem() : SessionItem(Constants::LayerZeroRoughnessType) {}
+LayerZeroRoughnessItem::LayerZeroRoughnessItem() : SessionItem("LayerZeroRoughness") {}
const QString LayerBasicRoughnessItem::P_SIGMA = QString::fromStdString("Sigma");
const QString LayerBasicRoughnessItem::P_HURST = QString::fromStdString("Hurst");
const QString LayerBasicRoughnessItem::P_LATERAL_CORR_LENGTH =
QString::fromStdString("CorrelationLength");
-LayerBasicRoughnessItem::LayerBasicRoughnessItem() : SessionItem(Constants::LayerBasicRoughnessType)
+LayerBasicRoughnessItem::LayerBasicRoughnessItem() : SessionItem("LayerBasicRoughness")
{
setToolTip(QStringLiteral("A roughness of interface between two layers."));
addProperty(P_SIGMA, 1.0)->setToolTip(QStringLiteral("rms of the roughness in nanometers"));
diff --git a/GUI/coregui/Models/MaskItems.cpp b/GUI/coregui/Models/MaskItems.cpp
index e60a782ce4aaf714a46348f042aeb04a7665aa47..4420591809f279dfa85a63a58067897a3cd7b1ad 100644
--- a/GUI/coregui/Models/MaskItems.cpp
+++ b/GUI/coregui/Models/MaskItems.cpp
@@ -20,14 +20,14 @@
#include "Core/Mask/Rectangle.h"
#include "GUI/coregui/utils/GUIHelpers.h"
-MaskContainerItem::MaskContainerItem() : SessionItem(Constants::MaskContainerType)
+MaskContainerItem::MaskContainerItem() : SessionItem("MaskContainer")
{
const QString T_MASKS = "Mask Tag";
QStringList allowedMasks = QStringList()
- << Constants::RectangleMaskType << Constants::PolygonMaskType
- << Constants::EllipseMaskType << Constants::VerticalLineMaskType
- << Constants::HorizontalLineMaskType << Constants::MaskAllType
- << Constants::RegionOfInterestType;
+ << "RectangleMask" << "PolygonMask"
+ << "EllipseMask" << "VerticalLineMask"
+ << "HorizontalLineMask" << "MaskAllMask"
+ << "RegionOfInterest";
registerTag(T_MASKS, 0, -1, allowedMasks);
setDefaultTag(T_MASKS);
}
@@ -75,7 +75,7 @@ std::unique_ptr<IShape2D> RectangleItem::createShape(double scale) const
/* ------------------------------------------------------------------------- */
-RegionOfInterestItem::RegionOfInterestItem() : RectangleItem(Constants::RegionOfInterestType)
+RegionOfInterestItem::RegionOfInterestItem() : RectangleItem("RegionOfInterest")
{
setItemValue(P_MASK_VALUE, false);
}
@@ -85,9 +85,9 @@ RegionOfInterestItem::RegionOfInterestItem() : RectangleItem(Constants::RegionOf
const QString PolygonPointItem::P_POSX = "X position";
const QString PolygonPointItem::P_POSY = "Y position";
-PolygonPointItem::PolygonPointItem() : SessionItem(Constants::PolygonPointType)
+PolygonPointItem::PolygonPointItem() : SessionItem("PolygonPoint")
{
- setItemName(Constants::PolygonPointType);
+ setItemName("PolygonPoint");
addProperty(P_POSX, 0.0)->setLimits(RealLimits::limitless());
addProperty(P_POSY, 0.0)->setLimits(RealLimits::limitless());
}
@@ -96,11 +96,11 @@ PolygonPointItem::PolygonPointItem() : SessionItem(Constants::PolygonPointType)
const QString PolygonItem::P_ISCLOSED = "Is closed";
-PolygonItem::PolygonItem() : MaskItem(Constants::PolygonMaskType)
+PolygonItem::PolygonItem() : MaskItem("PolygonMask")
{
- setItemName(Constants::PolygonMaskType);
+ setItemName("PolygonMask");
const QString T_POINTS = "Point tag";
- registerTag(T_POINTS, 0, -1, QStringList() << Constants::PolygonPointType);
+ registerTag(T_POINTS, 0, -1, QStringList() << "PolygonPoint");
setDefaultTag(T_POINTS);
addProperty(P_ISCLOSED, false)->setVisible(false);
}
@@ -108,7 +108,7 @@ PolygonItem::PolygonItem() : MaskItem(Constants::PolygonMaskType)
std::unique_ptr<IShape2D> PolygonItem::createShape(double scale) const
{
std::vector<double> x, y;
- for (auto item : this->getChildrenOfType(Constants::PolygonPointType)) {
+ for (auto item : this->getChildrenOfType("PolygonPoint")) {
x.push_back(scale * item->getItemValue(PolygonPointItem::P_POSX).toDouble());
y.push_back(scale * item->getItemValue(PolygonPointItem::P_POSY).toDouble());
}
@@ -118,9 +118,9 @@ std::unique_ptr<IShape2D> PolygonItem::createShape(double scale) const
/* ------------------------------------------------------------------------- */
const QString VerticalLineItem::P_POSX = "X position";
-VerticalLineItem::VerticalLineItem() : MaskItem(Constants::VerticalLineMaskType)
+VerticalLineItem::VerticalLineItem() : MaskItem("VerticalLineMask")
{
- setItemName(Constants::VerticalLineMaskType);
+ setItemName("VerticalLineMask");
addProperty(P_POSX, 0.0)->setLimits(RealLimits::limitless());
}
@@ -133,9 +133,9 @@ std::unique_ptr<IShape2D> VerticalLineItem::createShape(double scale) const
/* ------------------------------------------------------------------------- */
const QString HorizontalLineItem::P_POSY = "Y position";
-HorizontalLineItem::HorizontalLineItem() : MaskItem(Constants::HorizontalLineMaskType)
+HorizontalLineItem::HorizontalLineItem() : MaskItem("HorizontalLineMask")
{
- setItemName(Constants::HorizontalLineMaskType);
+ setItemName("HorizontalLineMask");
addProperty(P_POSY, 0.0)->setLimits(RealLimits::limitless());
}
@@ -153,9 +153,9 @@ const QString EllipseItem::P_XRADIUS = "X radius";
const QString EllipseItem::P_YRADIUS = "Y radius";
const QString EllipseItem::P_ANGLE = "Angle";
-EllipseItem::EllipseItem() : MaskItem(Constants::EllipseMaskType)
+EllipseItem::EllipseItem() : MaskItem("EllipseMask")
{
- setItemName(Constants::EllipseMaskType);
+ setItemName("EllipseMask");
addProperty(P_XCENTER, 0.0)->setLimits(RealLimits::limitless());
addProperty(P_YCENTER, 0.0)->setLimits(RealLimits::limitless());
addProperty(P_XRADIUS, 0.0);
@@ -176,9 +176,9 @@ std::unique_ptr<IShape2D> EllipseItem::createShape(double scale) const
/* ------------------------------------------------------------------------- */
-MaskAllItem::MaskAllItem() : MaskItem(Constants::MaskAllType)
+MaskAllItem::MaskAllItem() : MaskItem("MaskAllMask")
{
- setItemName(Constants::MaskAllType);
+ setItemName("MaskAllMask");
getItem(MaskItem::P_MASK_VALUE)->setEnabled(false);
}
diff --git a/GUI/coregui/Models/MaskItems.h b/GUI/coregui/Models/MaskItems.h
index de883df1d0dcbfbd81c0408fbbe185aa478ba15c..cfa3a6b201e549764ef51487e22729ea768d451b 100644
--- a/GUI/coregui/Models/MaskItems.h
+++ b/GUI/coregui/Models/MaskItems.h
@@ -45,7 +45,7 @@ public:
static const QString P_YLOW;
static const QString P_XUP;
static const QString P_YUP;
- explicit RectangleItem(const QString& modelType = Constants::RectangleMaskType);
+ explicit RectangleItem(const QString& modelType = "RectangleMask");
virtual std::unique_ptr<IShape2D> createShape(double scale) const;
};
diff --git a/GUI/coregui/Models/MaterialDataItems.cpp b/GUI/coregui/Models/MaterialDataItems.cpp
index 3e3ca7cb3770f61a6c523ceee2712dd72eb88f80..1eb1561198cd0da541b692a194289eb1c50e7427 100644
--- a/GUI/coregui/Models/MaterialDataItems.cpp
+++ b/GUI/coregui/Models/MaterialDataItems.cpp
@@ -25,14 +25,14 @@ const QString MaterialRefractiveDataItem::P_DELTA = "Delta";
const QString MaterialRefractiveDataItem::P_BETA = "Beta";
MaterialRefractiveDataItem::MaterialRefractiveDataItem()
- : MaterialDataItem(Constants::MaterialRefractiveDataType)
+ : MaterialDataItem("MaterialRefractiveData")
{
addProperty(P_DELTA, 0.0)
- ->setEditorType(Constants::ScientificEditorType)
+ ->setEditorType("ScientificDouble")
.setLimits(RealLimits::limitless())
.setToolTip("Delta of refractive index (n = 1 - delta + i*beta)");
addProperty(P_BETA, 0.0)
- ->setEditorType(Constants::ScientificEditorType)
+ ->setEditorType("ScientificDouble")
.setLimits(RealLimits::limitless())
.setToolTip("Beta of refractive index (n = 1 - delta + i*beta)");
}
@@ -42,14 +42,14 @@ MaterialRefractiveDataItem::MaterialRefractiveDataItem()
const QString MaterialSLDDataItem::P_SLD_REAL = "SLD, real";
const QString MaterialSLDDataItem::P_SLD_IMAG = "SLD, imaginary";
-MaterialSLDDataItem::MaterialSLDDataItem() : MaterialDataItem(Constants::MaterialSLDDataType)
+MaterialSLDDataItem::MaterialSLDDataItem() : MaterialDataItem("MaterialSLDData")
{
addProperty(P_SLD_REAL, 0.0)
- ->setEditorType(Constants::ScientificEditorType)
+ ->setEditorType("ScientificDouble")
.setLimits(RealLimits::limitless())
.setToolTip("Real part of SLD (SLD = real - i*imag), AA^{-2}");
addProperty(P_SLD_IMAG, 0.0)
- ->setEditorType(Constants::ScientificEditorType)
+ ->setEditorType("ScientificDouble")
.setLimits(RealLimits::limitless())
.setToolTip("Imaginary part of SLD (SLD = real - i*imag), AA^{-2}");
}
diff --git a/GUI/coregui/Models/MaterialItem.cpp b/GUI/coregui/Models/MaterialItem.cpp
index ff75e3b4e6aec68c525288a8632992d4425facfd..b7419f943362379427a436aca41df440e8bb09fb 100644
--- a/GUI/coregui/Models/MaterialItem.cpp
+++ b/GUI/coregui/Models/MaterialItem.cpp
@@ -32,15 +32,15 @@ const QString MaterialItem::P_MATERIAL_DATA = "Material data";
const QString MaterialItem::P_MAGNETIZATION = "Magnetization";
const QString MaterialItem::P_IDENTIFIER = "Identifier";
-MaterialItem::MaterialItem() : SessionItem(Constants::MaterialType)
+MaterialItem::MaterialItem() : SessionItem("Material")
{
- setItemName(Constants::MaterialType);
+ setItemName("Material");
ExternalProperty color = MaterialItemUtils::colorProperty(QColor(Qt::red));
- addProperty(P_COLOR, color.variant())->setEditorType(Constants::ColorEditorExternalType);
+ addProperty(P_COLOR, color.variant())->setEditorType("ExtColorEditor");
- addGroupProperty(P_MATERIAL_DATA, Constants::MaterialDataGroup);
- addGroupProperty(P_MAGNETIZATION, Constants::VectorType)->setToolTip(magnetization_tooltip);
+ addGroupProperty(P_MATERIAL_DATA, "Material data group");
+ addGroupProperty(P_MAGNETIZATION, "Vector")->setToolTip(magnetization_tooltip);
addProperty(P_IDENTIFIER, GUIHelpers::createUuid());
getItem(P_IDENTIFIER)->setVisible(false);
}
@@ -49,7 +49,7 @@ MaterialItem::MaterialItem() : SessionItem(Constants::MaterialType)
void MaterialItem::setRefractiveData(double delta, double beta)
{
- auto refractiveData = setGroupProperty(P_MATERIAL_DATA, Constants::MaterialRefractiveDataType);
+ auto refractiveData = setGroupProperty(P_MATERIAL_DATA, "MaterialRefractiveData");
refractiveData->setItemValue(MaterialRefractiveDataItem::P_DELTA, delta);
refractiveData->setItemValue(MaterialRefractiveDataItem::P_BETA, beta);
}
@@ -58,7 +58,7 @@ void MaterialItem::setRefractiveData(double delta, double beta)
void MaterialItem::setSLDData(double sld_real, double sld_imag)
{
- auto sldData = setGroupProperty(P_MATERIAL_DATA, Constants::MaterialSLDDataType);
+ auto sldData = setGroupProperty(P_MATERIAL_DATA, "MaterialSLDData");
sldData->setItemValue(MaterialSLDDataItem::P_SLD_REAL, sld_real);
sldData->setItemValue(MaterialSLDDataItem::P_SLD_IMAG, sld_imag);
}
@@ -80,12 +80,12 @@ std::unique_ptr<Material> MaterialItem::createMaterial() const
auto magnetization = GetVectorItem(*this, P_MAGNETIZATION);
auto name = itemName().toStdString();
- if (dataItem->modelType() == Constants::MaterialRefractiveDataType) {
+ if (dataItem->modelType() == "MaterialRefractiveData") {
double delta = dataItem->getItemValue(MaterialRefractiveDataItem::P_DELTA).toDouble();
double beta = dataItem->getItemValue(MaterialRefractiveDataItem::P_BETA).toDouble();
return std::make_unique<Material>(HomogeneousMaterial(name, delta, beta, magnetization));
- } else if (dataItem->modelType() == Constants::MaterialSLDDataType) {
+ } else if (dataItem->modelType() == "MaterialSLDData") {
double sld_real = dataItem->getItemValue(MaterialSLDDataItem::P_SLD_REAL).toDouble();
double sld_imag = dataItem->getItemValue(MaterialSLDDataItem::P_SLD_IMAG).toDouble();
return std::make_unique<Material>(MaterialBySLD(name, sld_real, sld_imag, magnetization));
diff --git a/GUI/coregui/Models/MaterialItemContainer.cpp b/GUI/coregui/Models/MaterialItemContainer.cpp
index 912ceec2a3f9c4d58b22dbbeb2d055d179df3d11..467c31163a99dd9357116300b2ccbaf27c93c3e8 100644
--- a/GUI/coregui/Models/MaterialItemContainer.cpp
+++ b/GUI/coregui/Models/MaterialItemContainer.cpp
@@ -19,10 +19,10 @@
const QString MaterialItemContainer::T_MATERIALS = "MaterialVector";
-MaterialItemContainer::MaterialItemContainer() : SessionItem(Constants::MaterialContainerType)
+MaterialItemContainer::MaterialItemContainer() : SessionItem("MaterialContainer")
{
setItemName("Materials");
- registerTag(T_MATERIALS, 0, -1, QStringList{Constants::MaterialType});
+ registerTag(T_MATERIALS, 0, -1, QStringList{"Material"});
}
MaterialItem* MaterialItemContainer::insertCopy(MaterialItem* material_item)
diff --git a/GUI/coregui/Models/MaterialModel.cpp b/GUI/coregui/Models/MaterialModel.cpp
index 97e83659fd4ab3c5803f72bf6c37e1f0b571e44e..68862979e59aeabaef9999c28fc1e69e04973a28 100644
--- a/GUI/coregui/Models/MaterialModel.cpp
+++ b/GUI/coregui/Models/MaterialModel.cpp
@@ -93,7 +93,7 @@ MaterialItem* MaterialModel::cloneMaterial(const QModelIndex& index)
MaterialItem* MaterialModel::createMaterial(const QString& name)
{
- auto result = dynamic_cast<MaterialItem*>(insertNewItem(Constants::MaterialType));
+ auto result = dynamic_cast<MaterialItem*>(insertNewItem("Material"));
result->setItemName(name);
QColor color = MaterialItemUtils::suggestMaterialColor(name);
diff --git a/GUI/coregui/Models/MaterialPropertyController.cpp b/GUI/coregui/Models/MaterialPropertyController.cpp
index aab6e4e7ca755666b9a7b92d9e34e7bc1ef0503c..014bdbfa2517f22597f4b081c510e07f96b79420 100644
--- a/GUI/coregui/Models/MaterialPropertyController.cpp
+++ b/GUI/coregui/Models/MaterialPropertyController.cpp
@@ -68,7 +68,7 @@ void MaterialPropertyController::onMaterialDataChanged(const QModelIndex& topLef
{
auto changedItem = m_materialModel->itemForIndex(topLeft);
if (auto materialItem = dynamic_cast<const MaterialItem*>(
- ModelPath::ancestor(changedItem, Constants::MaterialType))) {
+ ModelPath::ancestor(changedItem, "Material"))) {
for (auto sampleItem : relatedSampleItems()) {
QString tag = MaterialItemUtils::materialTag(*sampleItem);
diff --git a/GUI/coregui/Models/MesoCrystalItem.cpp b/GUI/coregui/Models/MesoCrystalItem.cpp
index 09e0210763f11326126c16786368d8f396146b43..e62e2e81f1fdb396aa01091c977e0816e0cc7b15 100644
--- a/GUI/coregui/Models/MesoCrystalItem.cpp
+++ b/GUI/coregui/Models/MesoCrystalItem.cpp
@@ -61,28 +61,28 @@ const QString MesoCrystalItem::P_VECTOR_C = "Third " + MesoCrystalItem::LATTICE_
// TODO make derived from ParticleItem
-MesoCrystalItem::MesoCrystalItem() : SessionGraphicsItem(Constants::MesoCrystalType)
+MesoCrystalItem::MesoCrystalItem() : SessionGraphicsItem("MesoCrystal")
{
setToolTip(QStringLiteral("A 3D crystal structure of nanoparticles"));
- addGroupProperty(P_FORM_FACTOR, Constants::FormFactorGroup);
+ addGroupProperty(P_FORM_FACTOR, "Form Factor");
addProperty(ParticleItem::P_ABUNDANCE, 1.0)
->setLimits(RealLimits::limited(0.0, 1.0))
.setDecimals(3)
.setToolTip(abundance_tooltip);
- addGroupProperty(P_VECTOR_A, Constants::VectorType)->setToolTip(lattice_vector1_tooltip);
- addGroupProperty(P_VECTOR_B, Constants::VectorType)->setToolTip(lattice_vector2_tooltip);
- addGroupProperty(P_VECTOR_C, Constants::VectorType)->setToolTip(lattice_vector3_tooltip);
- addGroupProperty(ParticleItem::P_POSITION, Constants::VectorType)->setToolTip(position_tooltip);
+ addGroupProperty(P_VECTOR_A, "Vector")->setToolTip(lattice_vector1_tooltip);
+ addGroupProperty(P_VECTOR_B, "Vector")->setToolTip(lattice_vector2_tooltip);
+ addGroupProperty(P_VECTOR_C, "Vector")->setToolTip(lattice_vector3_tooltip);
+ addGroupProperty(ParticleItem::P_POSITION, "Vector")->setToolTip(position_tooltip);
registerTag(T_BASIS_PARTICLE, 0, 1,
- QStringList() << Constants::ParticleType << Constants::ParticleCoreShellType
- << Constants::ParticleCompositionType << Constants::MesoCrystalType);
+ QStringList() << "Particle" << "ParticleCoreShell"
+ << "ParticleComposition" << "MesoCrystal");
setDefaultTag(T_BASIS_PARTICLE);
- registerTag(ParticleItem::T_TRANSFORMATION, 0, 1, QStringList() << Constants::RotationType);
+ registerTag(ParticleItem::T_TRANSFORMATION, 0, 1, QStringList() << "Rotation");
addTranslator(VectorParameterTranslator(ParticleItem::P_POSITION, "Position"));
addTranslator(RotationTranslator());
@@ -151,16 +151,16 @@ std::unique_ptr<IParticle> MesoCrystalItem::getBasis() const
{
QVector<SessionItem*> childlist = children();
for (int i = 0; i < childlist.size(); ++i) {
- if (childlist[i]->modelType() == Constants::ParticleType) {
+ if (childlist[i]->modelType() == "Particle") {
auto* particle_item = static_cast<ParticleItem*>(childlist[i]);
return particle_item->createParticle();
- } else if (childlist[i]->modelType() == Constants::ParticleCoreShellType) {
+ } else if (childlist[i]->modelType() == "ParticleCoreShell") {
auto* particle_coreshell_item = static_cast<ParticleCoreShellItem*>(childlist[i]);
return particle_coreshell_item->createParticleCoreShell();
- } else if (childlist[i]->modelType() == Constants::ParticleCompositionType) {
+ } else if (childlist[i]->modelType() == "ParticleComposition") {
auto* particlecomposition_item = static_cast<ParticleCompositionItem*>(childlist[i]);
return particlecomposition_item->createParticleComposition();
- } else if (childlist[i]->modelType() == Constants::MesoCrystalType) {
+ } else if (childlist[i]->modelType() == "MesoCrystal") {
auto* mesocrystal_item = static_cast<MesoCrystalItem*>(childlist[i]);
return mesocrystal_item->createMesoCrystal();
}
@@ -178,9 +178,9 @@ namespace
{
bool IsIParticleName(QString name)
{
- return (name.startsWith(Constants::ParticleType)
- || name.startsWith(Constants::ParticleCompositionType)
- || name.startsWith(Constants::ParticleCoreShellType)
- || name.startsWith(Constants::MesoCrystalType));
+ return (name.startsWith("Particle")
+ || name.startsWith("ParticleComposition")
+ || name.startsWith("ParticleCoreShell")
+ || name.startsWith("MesoCrystal"));
}
} // namespace
diff --git a/GUI/coregui/Models/MinimizerItem.cpp b/GUI/coregui/Models/MinimizerItem.cpp
index 5adf56bc2960fb84201e2fe5c426c5e28a7373a8..2aa4f5fc01c51020995446a85a05cd8125d3e7a7 100644
--- a/GUI/coregui/Models/MinimizerItem.cpp
+++ b/GUI/coregui/Models/MinimizerItem.cpp
@@ -32,9 +32,9 @@ const QString MinimizerContainerItem::P_MINIMIZERS = "Minimizer";
const QString MinimizerContainerItem::P_METRIC = "Objective metric";
const QString MinimizerContainerItem::P_NORM = "Norm function";
-MinimizerContainerItem::MinimizerContainerItem() : MinimizerItem(Constants::MinimizerContainerType)
+MinimizerContainerItem::MinimizerContainerItem() : MinimizerItem("MinimizerContainer")
{
- addGroupProperty(P_MINIMIZERS, Constants::MinimizerLibraryGroup)
+ addGroupProperty(P_MINIMIZERS, "Minimizer library group")
->setToolTip(QStringLiteral("Minimizer library"));
ComboProperty metric_combo;
@@ -76,7 +76,7 @@ const QString MinuitMinimizerItem::P_PRECISION = QString::fromStdString(OptionNa
const QString MinuitMinimizerItem::P_MAXFUNCTIONCALLS =
QString::fromStdString(OptionNames::MaxFunctionCalls);
-MinuitMinimizerItem::MinuitMinimizerItem() : MinimizerItem(Constants::MinuitMinimizerType)
+MinuitMinimizerItem::MinuitMinimizerItem() : MinimizerItem("Minuit2")
{
addProperty(P_ALGORITHMS, MinimizerItemCatalogue::algorithmCombo(modelType()).variant());
@@ -116,7 +116,7 @@ const QString GSLMultiMinimizerItem::P_ALGORITHMS = "Algorithms";
const QString GSLMultiMinimizerItem::P_MAXITERATIONS =
QString::fromStdString(OptionNames::MaxIterations);
-GSLMultiMinimizerItem::GSLMultiMinimizerItem() : MinimizerItem(Constants::GSLMultiMinimizerType)
+GSLMultiMinimizerItem::GSLMultiMinimizerItem() : MinimizerItem("GSLMultiMin")
{
addProperty(P_ALGORITHMS, MinimizerItemCatalogue::algorithmCombo(modelType()).variant());
addProperty(P_MAXITERATIONS, 0)->setToolTip("Maximum number of iterations");
@@ -140,7 +140,7 @@ const QString GeneticMinimizerItem::P_POPULATIONSIZE =
QString::fromStdString(OptionNames::PopulationSize);
const QString GeneticMinimizerItem::P_RANDOMSEED = QString::fromStdString(OptionNames::RandomSeed);
-GeneticMinimizerItem::GeneticMinimizerItem() : MinimizerItem(Constants::GeneticMinimizerType)
+GeneticMinimizerItem::GeneticMinimizerItem() : MinimizerItem("Genetic")
{
addProperty(P_TOLERANCE, 0.01)->setToolTip("Tolerance on the function value at the minimum");
addProperty(P_MAXITERATIONS, 3)->setToolTip("Maximum number of iterations");
@@ -172,7 +172,7 @@ const QString SimAnMinimizerItem::P_BOLTZMANN_MU = QString::fromStdString(Option
const QString SimAnMinimizerItem::P_BOLTZMANN_TMIN =
QString::fromStdString(OptionNames::BoltzmannTmin);
-SimAnMinimizerItem::SimAnMinimizerItem() : MinimizerItem(Constants::GSLSimAnMinimizerType)
+SimAnMinimizerItem::SimAnMinimizerItem() : MinimizerItem("GSLSimAn")
{
addProperty(P_MAXITERATIONS, 100)->setToolTip("Number of points to try for each step");
addProperty(P_ITERATIONSTEMP, 10)->setToolTip("Number of iterations at each temperature");
@@ -202,7 +202,7 @@ const QString GSLLMAMinimizerItem::P_TOLERANCE = QString::fromStdString(OptionNa
const QString GSLLMAMinimizerItem::P_MAXITERATIONS =
QString::fromStdString(OptionNames::MaxIterations);
-GSLLMAMinimizerItem::GSLLMAMinimizerItem() : MinimizerItem(Constants::GSLLMAMinimizerType)
+GSLLMAMinimizerItem::GSLLMAMinimizerItem() : MinimizerItem("GSLLMA")
{
addProperty(P_TOLERANCE, 0.01)->setToolTip("Tolerance on the function value at the minimum");
addProperty(P_MAXITERATIONS, 0)->setToolTip("Maximum number of iterations");
@@ -218,7 +218,7 @@ std::unique_ptr<IMinimizer> GSLLMAMinimizerItem::createMinimizer() const
// ----------------------------------------------------------------------------
-TestMinimizerItem::TestMinimizerItem() : MinimizerItem(Constants::TestMinimizerType) {}
+TestMinimizerItem::TestMinimizerItem() : MinimizerItem("Test") {}
std::unique_ptr<IMinimizer> TestMinimizerItem::createMinimizer() const
{
diff --git a/GUI/coregui/Models/ModelPath.cpp b/GUI/coregui/Models/ModelPath.cpp
index 95e37c3f5e3ec02a6de971ea1a9c48164808df6c..9c56ec46415cbafecff5e662e6fef01a9b6219ca 100644
--- a/GUI/coregui/Models/ModelPath.cpp
+++ b/GUI/coregui/Models/ModelPath.cpp
@@ -39,8 +39,8 @@ QModelIndex ModelPath::getIndexFromPath(const SessionModel* model, const QString
QStringList parts = path.split("/");
SessionItem* t = model->rootItem();
for (int i = 0; i < parts.length(); i++) {
- if (t->modelType() == Constants::JobItemType
- && parts[i] == Constants::GISASInstrumentType) {
+ if (t->modelType() == "JobItem"
+ && parts[i] == "GISASInstrument") {
t = t->getItem(JobItem::T_INSTRUMENT);
continue;
}
diff --git a/GUI/coregui/Models/MultiLayerItem.cpp b/GUI/coregui/Models/MultiLayerItem.cpp
index e97f178c88725ca56757d49974c576ab3292ee64..3955a3ae82c0a5003873491dcd983de05de8fb19 100644
--- a/GUI/coregui/Models/MultiLayerItem.cpp
+++ b/GUI/coregui/Models/MultiLayerItem.cpp
@@ -26,18 +26,18 @@ const QString MultiLayerItem::P_CROSS_CORR_LENGTH =
const QString MultiLayerItem::P_EXTERNAL_FIELD = "ExternalField";
const QString MultiLayerItem::T_LAYERS = "Layer tag";
-MultiLayerItem::MultiLayerItem() : SessionGraphicsItem(Constants::MultiLayerType)
+MultiLayerItem::MultiLayerItem() : SessionGraphicsItem("MultiLayer")
{
setToolTip(QStringLiteral("A multilayer to hold stack of layers"));
- setItemName(Constants::MultiLayerType);
+ setItemName("MultiLayer");
addProperty(P_CROSS_CORR_LENGTH, 0.0)
->setDecimals(5)
.setToolTip(QStringLiteral("Cross correlation length of roughnesses \n"
"between interfaces in nanometers"));
- addGroupProperty(P_EXTERNAL_FIELD, Constants::VectorType)->setToolTip(external_field_tooltip);
+ addGroupProperty(P_EXTERNAL_FIELD, "Vector")->setToolTip(external_field_tooltip);
- registerTag(T_LAYERS, 0, -1, QStringList() << Constants::LayerType);
+ registerTag(T_LAYERS, 0, -1, QStringList() << "Layer");
setDefaultTag(T_LAYERS);
addTranslator(RoughnessTranslator(this));
@@ -56,7 +56,7 @@ QVector<SessionItem*> MultiLayerItem::materialPropertyItems()
void MultiLayerItem::updateLayers()
{
- QVector<SessionItem*> list = getChildrenOfType(Constants::LayerType);
+ QVector<SessionItem*> list = getChildrenOfType("Layer");
for (auto it = list.begin(); it != list.end(); ++it) {
if (it == list.begin())
(*it)->getItem(LayerItem::P_ROUGHNESS)->setEnabled(false);
diff --git a/GUI/coregui/Models/ParameterTranslators.cpp b/GUI/coregui/Models/ParameterTranslators.cpp
index 53cbe5a5ddf6124265c7b8b889693cb9f04bb4c9..66c63c0f13df559642221be8c4d369c2b31d0b0f 100644
--- a/GUI/coregui/Models/ParameterTranslators.cpp
+++ b/GUI/coregui/Models/ParameterTranslators.cpp
@@ -70,7 +70,7 @@ QStringList AddElementTranslator::translate(const QStringList& list) const
QStringList RotationTranslator::translate(const QStringList& list) const
{
- if (list.back() != Constants::RotationType)
+ if (list.back() != "Rotation")
return list;
Q_ASSERT(list.size() == 3);
@@ -81,7 +81,7 @@ QStringList RotationTranslator::translate(const QStringList& list) const
QStringList DistributionNoneTranslator::translate(const QStringList& list) const
{
- if (list.back() != Constants::DistributionNoneType)
+ if (list.back() != "DistributionNone")
return list;
Q_UNUSED(list);
@@ -102,7 +102,7 @@ QStringList RoughnessTranslator::translate(const QStringList& list) const
if (list.empty())
return {};
- if (!list.back().contains(Constants::LayerType)
+ if (!list.back().contains("Layer")
|| !expectedRoughnessPars.contains(list.front()))
return list;
@@ -120,7 +120,7 @@ QStringList RoughnessTranslator::translate(const QStringList& list) const
int RoughnessTranslator::getLayerIndex(QString layerName) const
{
- layerName.remove(Constants::LayerType);
+ layerName.remove("Layer");
bool ok(true);
int layerIndex = layerName.toInt(&ok);
if (!ok)
@@ -130,7 +130,7 @@ int RoughnessTranslator::getLayerIndex(QString layerName) const
int RoughnessTranslator::numberOfLayers() const
{
- QVector<SessionItem*> list = mp_parent->getChildrenOfType(Constants::LayerType);
+ QVector<SessionItem*> list = mp_parent->getChildrenOfType("Layer");
return list.size();
}
diff --git a/GUI/coregui/Models/ParameterTreeItems.cpp b/GUI/coregui/Models/ParameterTreeItems.cpp
index b6520a3b47c91280e5870e581d88c8a19b0e8527..c6f95e66d52d7abaa5d68e4e9e3fae651bada672 100644
--- a/GUI/coregui/Models/ParameterTreeItems.cpp
+++ b/GUI/coregui/Models/ParameterTreeItems.cpp
@@ -19,18 +19,18 @@
// ----------------------------------------------------------------------------
-ParameterLabelItem::ParameterLabelItem() : SessionItem(Constants::ParameterLabelType)
+ParameterLabelItem::ParameterLabelItem() : SessionItem("Parameter Label")
{
const QString T_CHILDREN = "children tag";
registerTag(T_CHILDREN, 0, -1,
- QStringList() << Constants::ParameterLabelType << Constants::ParameterType);
+ QStringList() << "Parameter Label" << "Parameter");
setDefaultTag(T_CHILDREN);
}
const QString ParameterItem::P_LINK = "Link";
const QString ParameterItem::P_BACKUP = "Backup";
const QString ParameterItem::P_DOMAIN = "Domain";
-ParameterItem::ParameterItem() : SessionItem(Constants::ParameterType)
+ParameterItem::ParameterItem() : SessionItem("Parameter")
{
// Link to original PropertyItem in one of components of MultiLayerItem or InstrumentItem
addProperty(P_LINK, "");
@@ -56,7 +56,7 @@ void ParameterItem::propagateValueToLink(double newValue)
SessionItem* ParameterItem::linkedItem()
{
- const SessionItem* jobItem = ModelPath::ancestor(this, Constants::JobItemType);
+ const SessionItem* jobItem = ModelPath::ancestor(this, "JobItem");
Q_ASSERT(jobItem);
QString link = jobItem->itemName() + "/" + getItemValue(P_LINK).toString();
return model()->itemForIndex(ModelPath::getIndexFromPath(model(), link));
@@ -72,9 +72,9 @@ void ParameterItem::restoreFromBackup()
// ----------------------------------------------------------------------------
-ParameterContainerItem::ParameterContainerItem() : SessionItem(Constants::ParameterContainerType)
+ParameterContainerItem::ParameterContainerItem() : SessionItem("Parameter Container")
{
const QString T_CHILDREN = "children tag";
- registerTag(T_CHILDREN, 0, -1, QStringList() << Constants::ParameterLabelType);
+ registerTag(T_CHILDREN, 0, -1, QStringList() << "Parameter Label");
setDefaultTag(T_CHILDREN);
}
diff --git a/GUI/coregui/Models/ParameterTreeUtils.cpp b/GUI/coregui/Models/ParameterTreeUtils.cpp
index c54b63fc3f3acec5b21ac528e8e4a6463ef77404..a6358ed1428d99a493a801418b60dc40a7a06340 100644
--- a/GUI/coregui/Models/ParameterTreeUtils.cpp
+++ b/GUI/coregui/Models/ParameterTreeUtils.cpp
@@ -37,7 +37,7 @@ QString removeLeadingSlash(const QString& name)
void populateDomainLinks(SessionItem* container)
{
- if (container->modelType() != Constants::ParameterContainerType)
+ if (container->modelType() != "Parameter Container")
throw GUIHelpers::Error("ParameterTreeUtils::populateParameterContainer() -> Error. "
"Not a ParameterContainerType.");
@@ -57,7 +57,7 @@ void handleItem(SessionItem* tree, const SessionItem* source);
void ParameterTreeUtils::createParameterTree(JobItem* jobItem)
{
SessionItem* container = jobItem->model()->insertNewItem(
- Constants::ParameterContainerType, jobItem->index(), -1, JobItem::T_PARAMETER_TREE);
+ "Parameter Container", jobItem->index(), -1, JobItem::T_PARAMETER_TREE);
populateParameterContainer(container, jobItem->getItem(JobItem::T_MATERIAL_CONTAINER));
@@ -79,12 +79,12 @@ void ParameterTreeUtils::createParameterTree(JobItem* jobItem)
void ParameterTreeUtils::populateParameterContainer(SessionItem* container,
const SessionItem* source)
{
- if (container->modelType() != Constants::ParameterContainerType)
+ if (container->modelType() != "Parameter Container")
throw GUIHelpers::Error("ParameterTreeUtils::populateParameterContainer() -> Error. "
"Not a ParameterContainerType.");
SessionItem* sourceLabel =
- container->model()->insertNewItem(Constants::ParameterLabelType, container->index());
+ container->model()->insertNewItem("Parameter Label", container->index());
handleItem(sourceLabel, source);
}
@@ -99,8 +99,8 @@ void ParameterTreeUtils::visitParameterContainer(SessionItem* container,
stack.push(current);
while (!stack.empty()) {
current = stack.pop();
- if (current->modelType() == Constants::ParameterLabelType
- || current->modelType() == Constants::ParameterContainerType) {
+ if (current->modelType() == "Parameter Label"
+ || current->modelType() == "Parameter Container") {
for (SessionItem* child : current->getItems())
stack.push(child);
} else {
@@ -145,7 +145,7 @@ QVector<QPair<QString, QString>> ParameterTreeUtils::parameterDictionary(const S
// Create container with ParameterItem's of given source item
SampleModel model;
- SessionItem* container = model.insertNewItem(Constants::ParameterContainerType);
+ SessionItem* container = model.insertNewItem("Parameter Container");
populateParameterContainer(container, source);
// Iterate through all ParameterItems and retrieve necessary data.
@@ -199,7 +199,7 @@ SessionItem* ParameterTreeUtils::parameterNameToLinkedItem(const QString& parNam
const SessionItem* source)
{
SampleModel model;
- SessionItem* container = model.insertNewItem(Constants::ParameterContainerType);
+ SessionItem* container = model.insertNewItem("Parameter Container");
populateParameterContainer(container, source);
// Iterate through all ParameterItems and retrieve necessary data.
@@ -222,12 +222,12 @@ namespace
void handleItem(SessionItem* tree, const SessionItem* source)
{
- if (tree->modelType() == Constants::ParameterLabelType) {
+ if (tree->modelType() == "Parameter Label") {
tree->setDisplayName(source->itemName());
}
- else if (tree->modelType() == Constants::ParameterType) {
+ else if (tree->modelType() == "Parameter") {
tree->setDisplayName(source->itemName());
double sourceValue = source->value().toDouble();
@@ -246,23 +246,23 @@ void handleItem(SessionItem* tree, const SessionItem* source)
for (SessionItem* child : source->children()) {
if (child->isVisible() && child->isEnabled()) {
- if (child->modelType() == Constants::PropertyType) {
+ if (child->modelType() == "Property") {
if (child->value().type() == QVariant::Double) {
SessionItem* branch =
- tree->model()->insertNewItem(Constants::ParameterType, tree->index());
+ tree->model()->insertNewItem("Parameter", tree->index());
handleItem(branch, child);
}
- } else if (child->modelType() == Constants::GroupItemType) {
+ } else if (child->modelType() == "GroupProperty") {
SessionItem* currentItem = dynamic_cast<GroupItem*>(child)->currentItem();
if (currentItem && currentItem->numberOfChildren() > 0) {
SessionItem* branch =
- tree->model()->insertNewItem(Constants::ParameterLabelType, tree->index());
+ tree->model()->insertNewItem("Parameter Label", tree->index());
handleItem(branch, currentItem);
}
} else {
SessionItem* branch =
- tree->model()->insertNewItem(Constants::ParameterLabelType, tree->index());
+ tree->model()->insertNewItem("Parameter Label", tree->index());
handleItem(branch, child);
}
}
diff --git a/GUI/coregui/Models/ParameterTuningModel.cpp b/GUI/coregui/Models/ParameterTuningModel.cpp
index 9f76be03feea9067152fd611bcd8b3dca7138482..f0214dfc99f26ed49de740276072b79792e6750c 100644
--- a/GUI/coregui/Models/ParameterTuningModel.cpp
+++ b/GUI/coregui/Models/ParameterTuningModel.cpp
@@ -30,7 +30,7 @@ Qt::ItemFlags ParameterTuningModel::flags(const QModelIndex& proxyIndex) const
result |= Qt::ItemIsEditable;
const QString modelType = sourceIndex.data(SessionFlags::ModelTypeRole).toString();
- if (modelType == Constants::ParameterType && getParameterItem(proxyIndex))
+ if (modelType == "Parameter" && getParameterItem(proxyIndex))
result |= Qt::ItemIsDragEnabled;
}
return result;
diff --git a/GUI/coregui/Models/ParticleCompositionItem.cpp b/GUI/coregui/Models/ParticleCompositionItem.cpp
index 756efc31848b21168f53789323509c2c90d0e271..1b574c65cea3a00d12278ae3d9b90463d9335ebf 100644
--- a/GUI/coregui/Models/ParticleCompositionItem.cpp
+++ b/GUI/coregui/Models/ParticleCompositionItem.cpp
@@ -37,7 +37,7 @@ const QString ParticleCompositionItem::T_PARTICLES = "Particle Tag";
// TODO make ParticleCoreShellItem and ParticleItem to derive from common base.
ParticleCompositionItem::ParticleCompositionItem()
- : SessionGraphicsItem(Constants::ParticleCompositionType)
+ : SessionGraphicsItem("ParticleComposition")
{
setToolTip(QStringLiteral("Composition of particles with fixed positions"));
@@ -46,13 +46,13 @@ ParticleCompositionItem::ParticleCompositionItem()
.setDecimals(3)
.setToolTip(abundance_tooltip);
- addGroupProperty(ParticleItem::P_POSITION, Constants::VectorType)->setToolTip(position_tooltip);
+ addGroupProperty(ParticleItem::P_POSITION, "Vector")->setToolTip(position_tooltip);
registerTag(T_PARTICLES, 0, -1,
- QStringList() << Constants::ParticleType << Constants::ParticleCoreShellType
- << Constants::ParticleCompositionType << Constants::MesoCrystalType);
+ QStringList() << "Particle" << "ParticleCoreShell"
+ << "ParticleComposition" << "MesoCrystal");
setDefaultTag(T_PARTICLES);
- registerTag(ParticleItem::T_TRANSFORMATION, 0, 1, QStringList() << Constants::RotationType);
+ registerTag(ParticleItem::T_TRANSFORMATION, 0, 1, QStringList() << "Rotation");
addTranslator(VectorParameterTranslator(ParticleItem::P_POSITION, "Position"));
addTranslator(RotationTranslator());
@@ -74,25 +74,25 @@ std::unique_ptr<ParticleComposition> ParticleCompositionItem::createParticleComp
P_composition->setAbundance(abundance);
QVector<SessionItem*> childlist = children();
for (int i = 0; i < childlist.size(); ++i) {
- if (childlist[i]->modelType() == Constants::ParticleType) {
+ if (childlist[i]->modelType() == "Particle") {
auto* particle_item = static_cast<ParticleItem*>(childlist[i]);
auto P_particle = particle_item->createParticle();
if (P_particle) {
P_composition->addParticle(*P_particle);
}
- } else if (childlist[i]->modelType() == Constants::ParticleCoreShellType) {
+ } else if (childlist[i]->modelType() == "ParticleCoreShell") {
auto* particle_coreshell_item = static_cast<ParticleCoreShellItem*>(childlist[i]);
auto P_particle_coreshell = particle_coreshell_item->createParticleCoreShell();
if (P_particle_coreshell) {
P_composition->addParticle(*P_particle_coreshell);
}
- } else if (childlist[i]->modelType() == Constants::ParticleCompositionType) {
+ } else if (childlist[i]->modelType() == "ParticleComposition") {
auto* particlecomposition_item = static_cast<ParticleCompositionItem*>(childlist[i]);
auto P_child_composition = particlecomposition_item->createParticleComposition();
if (P_child_composition) {
P_composition->addParticle(*P_child_composition);
}
- } else if (childlist[i]->modelType() == Constants::MesoCrystalType) {
+ } else if (childlist[i]->modelType() == "MesoCrystal") {
auto* mesocrystal_item = static_cast<MesoCrystalItem*>(childlist[i]);
auto P_child_meso = mesocrystal_item->createMesoCrystal();
if (P_child_meso) {
diff --git a/GUI/coregui/Models/ParticleCoreShellItem.cpp b/GUI/coregui/Models/ParticleCoreShellItem.cpp
index 9f120e1b6ce42f48fa457b4d4715bcc1cd3ec6c1..8422ef89652a06ab5ee825e3adc70ba47a43c95d 100644
--- a/GUI/coregui/Models/ParticleCoreShellItem.cpp
+++ b/GUI/coregui/Models/ParticleCoreShellItem.cpp
@@ -37,7 +37,7 @@ const QString ParticleCoreShellItem::T_SHELL = "Shell Tag";
// TODO make ParticleCoreShellItem and ParticleItem to derive from common base.
ParticleCoreShellItem::ParticleCoreShellItem()
- : SessionGraphicsItem(Constants::ParticleCoreShellType)
+ : SessionGraphicsItem("ParticleCoreShell")
{
setToolTip(QStringLiteral("A particle with a core/shell geometry"));
@@ -46,11 +46,11 @@ ParticleCoreShellItem::ParticleCoreShellItem()
.setDecimals(3)
.setToolTip(abundance_tooltip);
- addGroupProperty(ParticleItem::P_POSITION, Constants::VectorType)->setToolTip(position_tooltip);
+ addGroupProperty(ParticleItem::P_POSITION, "Vector")->setToolTip(position_tooltip);
- registerTag(T_CORE, 0, 1, QStringList() << Constants::ParticleType);
- registerTag(T_SHELL, 0, 1, QStringList() << Constants::ParticleType);
- registerTag(ParticleItem::T_TRANSFORMATION, 0, 1, QStringList() << Constants::RotationType);
+ registerTag(T_CORE, 0, 1, QStringList() << "Particle");
+ registerTag(T_SHELL, 0, 1, QStringList() << "Particle");
+ registerTag(ParticleItem::T_TRANSFORMATION, 0, 1, QStringList() << "Rotation");
addTranslator(VectorParameterTranslator(ParticleItem::P_POSITION, "Position"));
addTranslator(RotationTranslator());
diff --git a/GUI/coregui/Models/ParticleDistributionItem.cpp b/GUI/coregui/Models/ParticleDistributionItem.cpp
index ea508354520eec824b1230d8e4ea79ec909546a9..05fb08994e4cb13861245690d0bd3e8f32ea2ab7 100644
--- a/GUI/coregui/Models/ParticleDistributionItem.cpp
+++ b/GUI/coregui/Models/ParticleDistributionItem.cpp
@@ -38,7 +38,7 @@ const QString ParticleDistributionItem::NO_SELECTION = "None";
const QString ParticleDistributionItem::T_PARTICLES = "Particle Tag";
ParticleDistributionItem::ParticleDistributionItem()
- : SessionGraphicsItem(Constants::ParticleDistributionType)
+ : SessionGraphicsItem("ParticleDistribution")
{
setToolTip(QStringLiteral("Collection of particles obtained via parametric distribution "
"of particle prototype"));
@@ -48,12 +48,12 @@ ParticleDistributionItem::ParticleDistributionItem()
.setDecimals(3)
.setToolTip(abundance_tooltip);
- addGroupProperty(P_DISTRIBUTION, Constants::DistributionGroup)
+ addGroupProperty(P_DISTRIBUTION, "Distribution group")
->setToolTip(QStringLiteral("Distribution to apply to the specified parameter"));
registerTag(T_PARTICLES, 0, 1,
- QStringList() << Constants::ParticleType << Constants::ParticleCoreShellType
- << Constants::ParticleCompositionType << Constants::MesoCrystalType);
+ QStringList() << "Particle" << "ParticleCoreShell"
+ << "ParticleComposition" << "MesoCrystal");
setDefaultTag(T_PARTICLES);
ComboProperty par_prop;
@@ -62,13 +62,13 @@ ParticleDistributionItem::ParticleDistributionItem()
addProperty(P_LINKED_PARAMETER, par_prop.variant())
->setToolTip(QStringLiteral("Linked parameter"))
- .setEditorType(Constants::MultiSelectionComboEditorType);
+ .setEditorType("MultiSelectionComboEditor");
updateMainParameterList();
mapper()->setOnAnyChildChange([this](SessionItem* item) {
// prevent infinit loop when item changes its own properties
- if (item && item->modelType() == Constants::PropertyType && item->parent() == this)
+ if (item && item->modelType() == "Property" && item->parent() == this)
return;
updateMainParameterList();
});
diff --git a/GUI/coregui/Models/ParticleItem.cpp b/GUI/coregui/Models/ParticleItem.cpp
index 8115e3ccd30775762781f5e453918035776d2a75..293fbbff2cfcd998ea527b64b95780bc27dd35a3 100644
--- a/GUI/coregui/Models/ParticleItem.cpp
+++ b/GUI/coregui/Models/ParticleItem.cpp
@@ -41,20 +41,20 @@ const QString ParticleItem::P_MATERIAL = "Material";
const QString ParticleItem::P_POSITION = "Position Offset";
const QString ParticleItem::T_TRANSFORMATION = "Transformation Tag";
-ParticleItem::ParticleItem() : SessionGraphicsItem(Constants::ParticleType)
+ParticleItem::ParticleItem() : SessionGraphicsItem("Particle")
{
- addGroupProperty(P_FORM_FACTOR, Constants::FormFactorGroup);
+ addGroupProperty(P_FORM_FACTOR, "Form Factor");
addProperty(P_MATERIAL, MaterialItemUtils::defaultMaterialProperty().variant())
->setToolTip(QStringLiteral("Material of particle"))
- .setEditorType(Constants::MaterialEditorExternalType);
+ .setEditorType("ExtMaterialEditor");
addProperty(P_ABUNDANCE, 1.0)
->setLimits(RealLimits::limited(0.0, 1.0))
.setDecimals(3)
.setToolTip(abundance_tooltip);
- addGroupProperty(P_POSITION, Constants::VectorType)->setToolTip(position_tooltip);
+ addGroupProperty(P_POSITION, "Vector")->setToolTip(position_tooltip);
- registerTag(T_TRANSFORMATION, 0, 1, QStringList() << Constants::RotationType);
+ registerTag(T_TRANSFORMATION, 0, 1, QStringList() << "Rotation");
setDefaultTag(T_TRANSFORMATION);
addTranslator(VectorParameterTranslator(P_POSITION, "Position"));
@@ -114,7 +114,7 @@ bool ParticleItem::isShellParticle() const
if (!parent())
return false;
- return parent()->modelType() == Constants::ParticleCoreShellType
+ return parent()->modelType() == "ParticleCoreShell"
&& parent()->tagFromItem(this) == ParticleCoreShellItem::T_SHELL;
}
@@ -125,5 +125,5 @@ bool ParticleItem::parentIsParticleLayout() const
if (!parent())
return false;
- return parent()->modelType() == Constants::ParticleLayoutType;
+ return parent()->modelType() == "ParticleLayout";
}
diff --git a/GUI/coregui/Models/ParticleLayoutItem.cpp b/GUI/coregui/Models/ParticleLayoutItem.cpp
index 0b5a0359a6513e581c3f7d322510d5aa7289ca70..69c7f01c6545204c4524ac56d7f3378c7007533d 100644
--- a/GUI/coregui/Models/ParticleLayoutItem.cpp
+++ b/GUI/coregui/Models/ParticleLayoutItem.cpp
@@ -24,10 +24,10 @@ namespace
//! Returns true if name is related to 2D interference functions.
bool isInterference2D(const QString& name)
{
- if (name == Constants::InterferenceFunction2DLatticeType
- || name == Constants::InterferenceFunction2DParaCrystalType
- || name == Constants::InterferenceFunctionFinite2DLatticeType
- || name == Constants::InterferenceFunctionHardDiskType)
+ if (name == "Interference2DLattice"
+ || name == "Interference2DParaCrystal"
+ || name == "InterferenceFinite2DLattice"
+ || name == "InterferenceHardDisk")
return true;
return false;
}
@@ -51,7 +51,7 @@ const QString ParticleLayoutItem::P_WEIGHT = QString::fromStdString("Weight");
const QString ParticleLayoutItem::T_PARTICLES = "Particle Tag";
const QString ParticleLayoutItem::T_INTERFERENCE = "Interference Tag";
-ParticleLayoutItem::ParticleLayoutItem() : SessionGraphicsItem(Constants::ParticleLayoutType)
+ParticleLayoutItem::ParticleLayoutItem() : SessionGraphicsItem("ParticleLayout")
{
setToolTip(QStringLiteral("A layout of particles"));
@@ -60,17 +60,17 @@ ParticleLayoutItem::ParticleLayoutItem() : SessionGraphicsItem(Constants::Partic
addProperty(P_WEIGHT, 1.0)->setToolTip(weight_tooltip);
registerTag(T_PARTICLES, 0, -1,
- QStringList() << Constants::ParticleType << Constants::ParticleCoreShellType
- << Constants::ParticleCompositionType << Constants::MesoCrystalType
- << Constants::ParticleDistributionType);
+ QStringList() << "Particle" << "ParticleCoreShell"
+ << "ParticleComposition" << "MesoCrystal"
+ << "ParticleDistribution");
setDefaultTag(T_PARTICLES);
registerTag(T_INTERFERENCE, 0, 1,
- QStringList() << Constants::InterferenceFunction1DLatticeType
- << Constants::InterferenceFunction2DLatticeType
- << Constants::InterferenceFunction2DParaCrystalType
- << Constants::InterferenceFunctionFinite2DLatticeType
- << Constants::InterferenceFunctionHardDiskType
- << Constants::InterferenceFunctionRadialParaCrystalType);
+ QStringList() << "Interference1DLattice"
+ << "Interference2DLattice"
+ << "Interference2DParaCrystal"
+ << "InterferenceFinite2DLattice"
+ << "InterferenceHardDisk"
+ << "InterferenceRadialParaCrystal");
mapper()->setOnChildrenChange([this](SessionItem*) {
updateDensityAppearance();
diff --git a/GUI/coregui/Models/PointwiseAxisItem.cpp b/GUI/coregui/Models/PointwiseAxisItem.cpp
index 5e868d0ea5024424a184b29037c346158ed00faa..633d4c34950b915b38b4d5d72e769986ad3a5b1d 100644
--- a/GUI/coregui/Models/PointwiseAxisItem.cpp
+++ b/GUI/coregui/Models/PointwiseAxisItem.cpp
@@ -28,13 +28,13 @@ const QString PointwiseAxisItem::P_NATIVE_UNITS = "NativeUnits";
const QString PointwiseAxisItem::P_FILE_NAME = "FileName";
PointwiseAxisItem::PointwiseAxisItem()
- : BasicAxisItem(Constants::PointwiseAxisType), m_instrument(nullptr)
+ : BasicAxisItem("PointwiseAxis"), m_instrument(nullptr)
{
getItem(P_MIN)->setEnabled(false);
getItem(P_NBINS)->setEnabled(false);
getItem(P_MAX)->setEnabled(false);
addProperty(P_FILE_NAME, QStringLiteral("undefined"))->setVisible(false);
- addProperty(P_NATIVE_UNITS, Constants::UnitsNbins)->setVisible(false);
+ addProperty(P_NATIVE_UNITS, "nbins")->setVisible(false);
setLastModified(QDateTime::currentDateTime());
mapper()->setOnPropertyChange([this](const QString& name) {
@@ -123,13 +123,13 @@ void PointwiseAxisItem::setLastModified(const QDateTime& dtime)
bool PointwiseAxisItem::checkValidity() const
{
- return m_axis && m_instrument && getUnitsLabel() != Constants::UnitsNbins;
+ return m_axis && m_instrument && getUnitsLabel() != "nbins";
}
void PointwiseAxisItem::findInstrument()
{
SessionItem* parent_item = parent();
- while (parent_item && parent_item->modelType() != Constants::SpecularInstrumentType)
+ while (parent_item && parent_item->modelType() != "SpecularInstrument")
parent_item = parent_item->parent();
m_instrument = static_cast<SpecularInstrumentItem*>(parent_item);
}
diff --git a/GUI/coregui/Models/ProjectionItems.cpp b/GUI/coregui/Models/ProjectionItems.cpp
index 60124a698a53ea72f0fc7e40daba17e598b4e575..b8ad0748f90bd618163e44dc98b13ba428ac9b22 100644
--- a/GUI/coregui/Models/ProjectionItems.cpp
+++ b/GUI/coregui/Models/ProjectionItems.cpp
@@ -14,11 +14,11 @@
#include "GUI/coregui/Models/ProjectionItems.h"
-ProjectionContainerItem::ProjectionContainerItem() : SessionItem(Constants::ProjectionContainerType)
+ProjectionContainerItem::ProjectionContainerItem() : SessionItem("ProjectionContainer")
{
const QString T_CHILDREN = "children tag";
registerTag(T_CHILDREN, 0, -1,
- QStringList() << Constants::HorizontalLineMaskType
- << Constants::VerticalLineMaskType);
+ QStringList() << "HorizontalLineMask"
+ << "VerticalLineMask");
setDefaultTag(T_CHILDREN);
}
diff --git a/GUI/coregui/Models/PropertyItem.cpp b/GUI/coregui/Models/PropertyItem.cpp
index afc19183b2ad7332884523900cf27e789c8a2670..1ca83870816f32f95727576d55d3f8812e059805 100644
--- a/GUI/coregui/Models/PropertyItem.cpp
+++ b/GUI/coregui/Models/PropertyItem.cpp
@@ -14,4 +14,4 @@
#include "GUI/coregui/Models/PropertyItem.h"
-PropertyItem::PropertyItem() : SessionItem(Constants::PropertyType) {}
+PropertyItem::PropertyItem() : SessionItem("Property") {}
diff --git a/GUI/coregui/Models/RealDataItem.cpp b/GUI/coregui/Models/RealDataItem.cpp
index 4cb00b1468ed93ee446ea232f7b2ca9753466520..029d73882b0ca7f066476eb30619fac20f95ca18 100644
--- a/GUI/coregui/Models/RealDataItem.cpp
+++ b/GUI/coregui/Models/RealDataItem.cpp
@@ -28,21 +28,21 @@ const QString RealDataItem::T_INTENSITY_DATA = "Intensity data";
const QString RealDataItem::T_NATIVE_DATA = "Native user data axis";
const QString RealDataItem::P_NATIVE_UNITS = "Native user data units";
-RealDataItem::RealDataItem() : SessionItem(Constants::RealDataType), m_linkedInstrument(nullptr)
+RealDataItem::RealDataItem() : SessionItem("RealData"), m_linkedInstrument(nullptr)
{
setItemName(QStringLiteral("undefined"));
// Registering this tag even without actual data item to avoid troubles in copying RealDataItem
registerTag(T_INTENSITY_DATA, 1, 1,
- QStringList() << Constants::IntensityDataType << Constants::SpecularDataType);
+ QStringList() << "IntensityData" << "SpecularData");
setDefaultTag(T_INTENSITY_DATA);
addProperty(P_INSTRUMENT_ID, QString());
addProperty(P_INSTRUMENT_NAME, QString());
registerTag(T_NATIVE_DATA, 1, 1,
- QStringList() << Constants::IntensityDataType << Constants::SpecularDataType);
- addProperty(P_NATIVE_UNITS, Constants::UnitsNbins)->setVisible(false);
+ QStringList() << "IntensityData" << "SpecularData");
+ addProperty(P_NATIVE_UNITS, "nbins")->setVisible(false);
mapper()->setOnPropertyChange([this](const QString& name) {
if (name == P_NAME)
@@ -104,8 +104,8 @@ void RealDataItem::setOutputData(OutputData<double>* data)
assert(data->getRank() < 3 && data->getRank() > 0);
const QString& target_model_type =
- data->getRank() == 2 ? Constants::IntensityDataType
- : data->getRank() == 1 ? Constants::SpecularDataType : "";
+ data->getRank() == 2 ? "IntensityData"
+ : data->getRank() == 1 ? "SpecularData" : "";
auto data_item = getItem(T_INTENSITY_DATA);
if (data_item && data_item->modelType() != target_model_type)
throw GUIHelpers::Error("Error in RealDataItem::setOutputData: trying to set data "
@@ -122,7 +122,7 @@ void RealDataItem::initDataItem(size_t data_rank, const QString& tag)
{
assert(data_rank <= 2 && data_rank > 0);
const QString& target_model_type =
- data_rank == 2 ? Constants::IntensityDataType : Constants::SpecularDataType;
+ data_rank == 2 ? "IntensityData" : "SpecularData";
auto data_item = getItem(tag);
if (data_item && data_item->modelType() != target_model_type)
throw GUIHelpers::Error("Error in RealDataItem::initDataItem: trying to set data "
@@ -150,7 +150,7 @@ void RealDataItem::setImportData(ImportDataInfo data)
bool RealDataItem::holdsDimensionalData() const
{
- return getItemValue(P_NATIVE_UNITS).toString() != Constants::UnitsNbins;
+ return getItemValue(P_NATIVE_UNITS).toString() != "nbins";
}
void RealDataItem::linkToInstrument(const InstrumentItem* instrument, bool make_update)
diff --git a/GUI/coregui/Models/RealLimitsItems.cpp b/GUI/coregui/Models/RealLimitsItems.cpp
index aad7b25cd5e1b06a9bdad3fa80d3ad71fdde120f..2c44942253f372f974955d57c13ee3d147b8268d 100644
--- a/GUI/coregui/Models/RealLimitsItems.cpp
+++ b/GUI/coregui/Models/RealLimitsItems.cpp
@@ -27,7 +27,7 @@ RealLimitsItem::RealLimitsItem(const QString& name) : SessionItem(name) {}
// --------------------------------------------------------------------------------------------- //
-LimitlessItem::LimitlessItem() : RealLimitsItem(Constants::RealLimitsLimitlessType) {}
+LimitlessItem::LimitlessItem() : RealLimitsItem("RealLimitsLimitless") {}
RealLimits LimitlessItem::createRealLimits(double /*scale_factor*/) const
{
@@ -36,7 +36,7 @@ RealLimits LimitlessItem::createRealLimits(double /*scale_factor*/) const
// --------------------------------------------------------------------------------------------- //
-PositiveItem::PositiveItem() : RealLimitsItem(Constants::RealLimitsPositiveType) {}
+PositiveItem::PositiveItem() : RealLimitsItem("RealLimitsPositive") {}
RealLimits PositiveItem::createRealLimits(double /*scale_factor*/) const
{
@@ -45,7 +45,7 @@ RealLimits PositiveItem::createRealLimits(double /*scale_factor*/) const
// --------------------------------------------------------------------------------------------- //
-NonnegativeItem::NonnegativeItem() : RealLimitsItem(Constants::RealLimitsNonnegativeType) {}
+NonnegativeItem::NonnegativeItem() : RealLimitsItem("RealLimitsNonnegative") {}
RealLimits NonnegativeItem::createRealLimits(double /*scale_factor*/) const
{
@@ -54,7 +54,7 @@ RealLimits NonnegativeItem::createRealLimits(double /*scale_factor*/) const
// --------------------------------------------------------------------------------------------- //
-LowerLimitedItem::LowerLimitedItem() : RealLimitsItem(Constants::RealLimitsLowerLimitedType)
+LowerLimitedItem::LowerLimitedItem() : RealLimitsItem("RealLimitsLowerLimited")
{
addProperty(P_XMIN, 0.0)->setToolTip(tooltip_min_value).setLimits(RealLimits::limitless());
}
@@ -66,7 +66,7 @@ RealLimits LowerLimitedItem::createRealLimits(double scale_factor) const
// --------------------------------------------------------------------------------------------- //
-UpperLimitedItem::UpperLimitedItem() : RealLimitsItem(Constants::RealLimitsUpperLimitedType)
+UpperLimitedItem::UpperLimitedItem() : RealLimitsItem("RealLimitsUpperLimited")
{
addProperty(P_XMAX, 1.0)->setToolTip(tooltip_max_value).setLimits(RealLimits::limitless());
}
@@ -78,7 +78,7 @@ RealLimits UpperLimitedItem::createRealLimits(double scale_factor) const
// --------------------------------------------------------------------------------------------- //
-LimitedItem::LimitedItem() : RealLimitsItem(Constants::RealLimitsLimitedType)
+LimitedItem::LimitedItem() : RealLimitsItem("RealLimitsLimited")
{
addProperty(P_XMIN, 0.0)->setToolTip(tooltip_min_value).setLimits(RealLimits::limitless());
addProperty(P_XMAX, 1.0)->setToolTip(tooltip_max_value).setLimits(RealLimits::limitless());
diff --git a/GUI/coregui/Models/RectangularDetectorItem.cpp b/GUI/coregui/Models/RectangularDetectorItem.cpp
index a9f00e18d2439d787bf0f901a9e8a09462567fb6..13cb40ad84dc22efb68aa820d307d554e604d677 100644
--- a/GUI/coregui/Models/RectangularDetectorItem.cpp
+++ b/GUI/coregui/Models/RectangularDetectorItem.cpp
@@ -52,10 +52,10 @@ const QString tooltip_samplex_v0 =
ComboProperty alignmentCombo()
{
ComboProperty result;
- result << Constants::ALIGNMENT_GENERIC << Constants::ALIGNMENT_TO_DIRECT_BEAM
- << Constants::ALIGNMENT_TO_SAMPLE << Constants::ALIGNMENT_TO_REFLECTED_BEAM
- << Constants::ALIGNMENT_TO_REFLECTED_BEAM_DPOS;
- result.setValue(Constants::ALIGNMENT_TO_DIRECT_BEAM);
+ result << "Generic" << "Perpendicular to direct beam"
+ << "Perpendicular to sample x-axis" << "Perpendicular to reflected beam"
+ << "Perpendicular to reflected beam (dpos)";
+ result.setValue("Perpendicular to direct beam");
return result;
}
} // namespace
@@ -72,17 +72,17 @@ const QString RectangularDetectorItem::P_DBEAM_V0 = "v0 (dbeam)";
const QString RectangularDetectorItem::P_DISTANCE = "Distance";
RectangularDetectorItem::RectangularDetectorItem()
- : DetectorItem(Constants::RectangularDetectorType), m_is_constructed(false)
+ : DetectorItem("RectangularDetector"), m_is_constructed(false)
{
// axes parameters
- SessionItem* item = addGroupProperty(P_X_AXIS, Constants::BasicAxisType);
+ SessionItem* item = addGroupProperty(P_X_AXIS, "BasicAxis");
item->getItem(BasicAxisItem::P_TITLE)->setVisible(false);
item->getItem(BasicAxisItem::P_MIN)->setVisible(false);
item->setItemValue(BasicAxisItem::P_MAX, default_detector_width);
item->getItem(BasicAxisItem::P_MAX)->setDisplayName(QStringLiteral("Width [mm]"));
item->getItem(BasicAxisItem::P_MAX)->setToolTip(QStringLiteral("Width of the detector in mm"));
- item = addGroupProperty(P_Y_AXIS, Constants::BasicAxisType);
+ item = addGroupProperty(P_Y_AXIS, "BasicAxis");
item->getItem(BasicAxisItem::P_TITLE)->setVisible(false);
item->getItem(BasicAxisItem::P_MIN)->setVisible(false);
item->setItemValue(BasicAxisItem::P_MAX, default_detector_height);
@@ -93,11 +93,11 @@ RectangularDetectorItem::RectangularDetectorItem()
addProperty(P_ALIGNMENT, alignmentCombo().variant());
// alignment parameters
- item = addGroupProperty(P_NORMAL, Constants::VectorType);
+ item = addGroupProperty(P_NORMAL, "Vector");
item->setItemValue(VectorItem::P_X, default_detector_distance);
// direction
- item = addGroupProperty(P_DIRECTION, Constants::VectorType);
+ item = addGroupProperty(P_DIRECTION, "Vector");
item->setItemValue(VectorItem::P_Y, -1.0);
addProperty(P_U0, default_detector_width / 2.)
@@ -179,15 +179,15 @@ std::unique_ptr<IDetector2D> RectangularDetectorItem::createDomainDetector() con
ComboProperty alignment = getItemValue(P_ALIGNMENT).value<ComboProperty>();
- if (alignment.getValue() == Constants::ALIGNMENT_GENERIC) {
+ if (alignment.getValue() == "Generic") {
result->setPosition(normalVector(), u0, v0, directionVector());
- } else if (alignment.getValue() == Constants::ALIGNMENT_TO_DIRECT_BEAM) {
+ } else if (alignment.getValue() == "Perpendicular to direct beam") {
result->setPerpendicularToDirectBeam(distance, dbeam_u0, dbeam_v0);
- } else if (alignment.getValue() == Constants::ALIGNMENT_TO_SAMPLE) {
+ } else if (alignment.getValue() == "Perpendicular to sample x-axis") {
result->setPerpendicularToSampleX(distance, u0, v0);
- } else if (alignment.getValue() == Constants::ALIGNMENT_TO_REFLECTED_BEAM) {
+ } else if (alignment.getValue() == "Perpendicular to reflected beam") {
result->setPerpendicularToReflectedBeam(distance, u0, v0);
- } else if (alignment.getValue() == Constants::ALIGNMENT_TO_REFLECTED_BEAM_DPOS) {
+ } else if (alignment.getValue() == "Perpendicular to reflected beam (dpos)") {
result->setPerpendicularToReflectedBeam(distance);
result->setDirectBeamPosition(dbeam_u0, dbeam_v0);
}
@@ -205,30 +205,30 @@ void RectangularDetectorItem::update_properties_appearance()
getItem(prop)->setVisible(false);
// enabling some properties back, depending from detector alignment mode
- if (alignment.getValue() == Constants::ALIGNMENT_GENERIC) {
+ if (alignment.getValue() == "Generic") {
getItem(P_NORMAL)->setVisible(true);
getItem(P_DIRECTION)->setVisible(true);
getItem(P_U0)->setVisible(true);
getItem(P_U0)->setToolTip(tooltip_u0);
getItem(P_V0)->setVisible(true);
getItem(P_V0)->setToolTip(tooltip_v0);
- } else if (alignment.getValue() == Constants::ALIGNMENT_TO_SAMPLE) {
+ } else if (alignment.getValue() == "Perpendicular to sample x-axis") {
getItem(P_DISTANCE)->setVisible(true);
getItem(P_U0)->setVisible(true);
getItem(P_U0)->setToolTip(tooltip_samplex_u0);
getItem(P_V0)->setVisible(true);
getItem(P_V0)->setToolTip(tooltip_samplex_v0);
- } else if (alignment.getValue() == Constants::ALIGNMENT_TO_DIRECT_BEAM) {
+ } else if (alignment.getValue() == "Perpendicular to direct beam") {
getItem(P_DISTANCE)->setVisible(true);
getItem(P_DBEAM_U0)->setVisible(true);
getItem(P_DBEAM_V0)->setVisible(true);
- } else if (alignment.getValue() == Constants::ALIGNMENT_TO_REFLECTED_BEAM) {
+ } else if (alignment.getValue() == "Perpendicular to reflected beam") {
getItem(P_DISTANCE)->setVisible(true);
getItem(P_U0)->setVisible(true);
getItem(P_U0)->setToolTip(tooltip_refbeam_u0);
getItem(P_V0)->setVisible(true);
getItem(P_V0)->setToolTip(tooltip_refbeam_v0);
- } else if (alignment.getValue() == Constants::ALIGNMENT_TO_REFLECTED_BEAM_DPOS) {
+ } else if (alignment.getValue() == "Perpendicular to reflected beam (dpos)") {
getItem(P_DISTANCE)->setVisible(true);
getItem(P_DBEAM_U0)->setVisible(true);
getItem(P_DBEAM_V0)->setVisible(true);
diff --git a/GUI/coregui/Models/ResolutionFunctionItems.cpp b/GUI/coregui/Models/ResolutionFunctionItems.cpp
index 8723f571b8a07f66ccc3165462bd108da8db8664..6c29bf2bb005ed742abdc0804fdb974039e46661 100644
--- a/GUI/coregui/Models/ResolutionFunctionItems.cpp
+++ b/GUI/coregui/Models/ResolutionFunctionItems.cpp
@@ -20,7 +20,7 @@ ResolutionFunctionItem::ResolutionFunctionItem(const QString& name) : SessionIte
/* --------------------------------------------------------------------------------------------- */
ResolutionFunctionNoneItem::ResolutionFunctionNoneItem()
- : ResolutionFunctionItem(Constants::ResolutionFunctionNoneType)
+ : ResolutionFunctionItem("ResolutionFunctionNone")
{
}
@@ -36,7 +36,7 @@ const QString ResolutionFunction2DGaussianItem::P_SIGMA_X = QString::fromStdStri
const QString ResolutionFunction2DGaussianItem::P_SIGMA_Y = QString::fromStdString("SigmaY");
ResolutionFunction2DGaussianItem::ResolutionFunction2DGaussianItem()
- : ResolutionFunctionItem(Constants::ResolutionFunction2DGaussianType)
+ : ResolutionFunctionItem("ResolutionFunction2DGaussian")
{
addProperty(P_SIGMA_X, 0.02)
->setLimits(RealLimits::lowerLimited(0.0))
diff --git a/GUI/coregui/Models/RotationItems.cpp b/GUI/coregui/Models/RotationItems.cpp
index 80f3da2e31fdb25e20edab6d01a9d864331f2512..a18b247c5043ffaccabd41dabd699e124452cdc5 100644
--- a/GUI/coregui/Models/RotationItems.cpp
+++ b/GUI/coregui/Models/RotationItems.cpp
@@ -20,7 +20,7 @@
const QString XRotationItem::P_ANGLE = "Angle";
-XRotationItem::XRotationItem() : RotationItem(Constants::XRotationType)
+XRotationItem::XRotationItem() : RotationItem("XRotation")
{
setToolTip(QStringLiteral("Particle rotation around x-axis"));
addProperty(P_ANGLE, 0.0)
@@ -37,7 +37,7 @@ std::unique_ptr<IRotation> XRotationItem::createRotation() const
const QString YRotationItem::P_ANGLE = "Angle";
-YRotationItem::YRotationItem() : RotationItem(Constants::YRotationType)
+YRotationItem::YRotationItem() : RotationItem("YRotation")
{
setToolTip(QStringLiteral("Particle rotation around y-axis"));
addProperty(P_ANGLE, 0.0)
@@ -54,7 +54,7 @@ std::unique_ptr<IRotation> YRotationItem::createRotation() const
const QString ZRotationItem::P_ANGLE = "Angle";
-ZRotationItem::ZRotationItem() : RotationItem(Constants::ZRotationType)
+ZRotationItem::ZRotationItem() : RotationItem("ZRotation")
{
setToolTip(QStringLiteral("Particle rotation around z-axis"));
addProperty(P_ANGLE, 0.0)
@@ -73,7 +73,7 @@ const QString EulerRotationItem::P_ALPHA = "Alpha";
const QString EulerRotationItem::P_BETA = "Beta";
const QString EulerRotationItem::P_GAMMA = "Gamma";
-EulerRotationItem::EulerRotationItem() : RotationItem(Constants::EulerRotationType)
+EulerRotationItem::EulerRotationItem() : RotationItem("EulerRotation")
{
setToolTip(QStringLiteral("Sequence of three rotations following Euler angles \n"
"notation z-x'-z'"));
diff --git a/GUI/coregui/Models/SampleValidator.cpp b/GUI/coregui/Models/SampleValidator.cpp
index 280f9b8ecfc5dfe0395cdd2cebfec417c8171e8e..4999de4487c8c4e95dfbf57ab2f7e6af55b375eb 100644
--- a/GUI/coregui/Models/SampleValidator.cpp
+++ b/GUI/coregui/Models/SampleValidator.cpp
@@ -43,15 +43,15 @@ void SampleValidator::validateItem(const SessionItem* item)
QString diagnosis;
- if (item->modelType() == Constants::MultiLayerType) {
+ if (item->modelType() == "MultiLayer") {
diagnosis = validateMultiLayerItem(item);
- } else if (item->modelType() == Constants::ParticleLayoutType) {
+ } else if (item->modelType() == "ParticleLayout") {
diagnosis = validateParticleLayoutItem(item);
- } else if (item->modelType() == Constants::ParticleCoreShellType) {
+ } else if (item->modelType() == "ParticleCoreShell") {
diagnosis = validateParticleCoreShellItem(item);
- } else if (item->modelType() == Constants::ParticleCompositionType) {
+ } else if (item->modelType() == "ParticleComposition") {
diagnosis = validateParticleCompositionItem(item);
- } else if (item->modelType() == Constants::ParticleDistributionType) {
+ } else if (item->modelType() == "ParticleDistribution") {
diagnosis = validateParticleDistributionItem(item);
}
if (!diagnosis.isEmpty()) {
diff --git a/GUI/coregui/Models/SessionDecorationModel.cpp b/GUI/coregui/Models/SessionDecorationModel.cpp
index 249b4a49fdf30bce1b3fc7d36ac332a648b1b862..fd30e9b18a5056388d52aab72046969591bc497f 100644
--- a/GUI/coregui/Models/SessionDecorationModel.cpp
+++ b/GUI/coregui/Models/SessionDecorationModel.cpp
@@ -64,19 +64,19 @@ QVariant itemIcon(const SessionItem* item)
auto& icons = iconCatalogue();
- if (modelType == Constants::GISASInstrumentType) {
+ if (modelType == "GISASInstrument") {
return QVariant(icons.gisasIcon);
- } else if (modelType == Constants::OffSpecInstrumentType) {
+ } else if (modelType == "OffSpecInstrument") {
return QVariant(icons.offspecIcon);
- } else if (modelType == Constants::SpecularInstrumentType) {
+ } else if (modelType == "SpecularInstrument") {
return QVariant(icons.specularIcon);
- } else if (modelType == Constants::DepthProbeInstrumentType) {
+ } else if (modelType == "DepthProbeInstrument") {
return QVariant(icons.depthIcon);
- } else if (modelType == Constants::MaterialType) {
+ } else if (modelType == "Material") {
auto materialItem = dynamic_cast<const MaterialItem*>(item);
return QVariant(materialIcon(materialItem->color()));
}
diff --git a/GUI/coregui/Models/SessionItem.cpp b/GUI/coregui/Models/SessionItem.cpp
index 5b8e7b797587ec9fe34ea207ad21c7985aa4e1d3..eaf73d66652cede28a71831d2ecfdc4c6a6dfd83 100644
--- a/GUI/coregui/Models/SessionItem.cpp
+++ b/GUI/coregui/Models/SessionItem.cpp
@@ -289,9 +289,9 @@ SessionItem* SessionItem::addProperty(const QString& name, const QVariant& varia
throw GUIHelpers::Error(
"ParameterizedItem::registerProperty() -> Error. Already existing property " + name);
- SessionItem* property = ItemFactory::CreateItem(Constants::PropertyType);
+ SessionItem* property = ItemFactory::CreateItem("Property");
property->setDisplayName(name);
- registerTag(name, 1, 1, QStringList() << Constants::PropertyType);
+ registerTag(name, 1, 1, QStringList() << "Property");
if (!insertItem(0, property, name))
throw GUIHelpers::Error("SessionItem::addProperty -> Error. Can't insert item");
@@ -330,10 +330,10 @@ SessionItem* SessionItem::addGroupProperty(const QString& groupTag, const QStrin
// create group item
GroupInfo groupInfo = SessionItemUtils::GetGroupInfo(groupType);
GroupItem* groupItem =
- dynamic_cast<GroupItem*>(ItemFactory::CreateItem(Constants::GroupItemType));
+ dynamic_cast<GroupItem*>(ItemFactory::CreateItem("GroupProperty"));
Q_ASSERT(groupItem);
groupItem->setGroupInfo(groupInfo);
- registerTag(groupTag, 1, 1, QStringList() << Constants::GroupItemType);
+ registerTag(groupTag, 1, 1, QStringList() << "GroupProperty");
result = groupItem;
} else {
// create single item
@@ -441,8 +441,8 @@ QString SessionItem::displayName() const
{
QString result = data(SessionFlags::DisplayNameRole).toString();
- if (modelType() == Constants::PropertyType || modelType() == Constants::GroupItemType
- || modelType() == Constants::ParameterType || modelType() == Constants::ParameterLabelType)
+ if (modelType() == "Property" || modelType() == "GroupProperty"
+ || modelType() == "Parameter" || modelType() == "Parameter Label")
return result;
if (m_parent) {
@@ -548,7 +548,7 @@ SessionItem& SessionItem::setToolTip(const QString& tooltip)
QString SessionItem::editorType() const
{
auto variant = data(SessionFlags::CustomEditorRole);
- return variant.isValid() ? variant.toString() : Constants::DefaultEditorType;
+ return variant.isValid() ? variant.toString() : "Default";
}
SessionItem& SessionItem::setEditorType(const QString& editorType)
diff --git a/GUI/coregui/Models/SessionItem.h b/GUI/coregui/Models/SessionItem.h
index f8043120c532f91bfb60ac352521c9991913d03b..2c15604ec3872852bc24283d6976588efb1aabca 100644
--- a/GUI/coregui/Models/SessionItem.h
+++ b/GUI/coregui/Models/SessionItem.h
@@ -17,7 +17,6 @@
#include "Fit/Tools/RealLimits.h"
#include "GUI/coregui/Models/ModelMapper.h"
-#include "GUI/coregui/Models/item_constants.h"
#include <QStringList>
#include <memory>
diff --git a/GUI/coregui/Models/SessionItemUtils.cpp b/GUI/coregui/Models/SessionItemUtils.cpp
index 885b6999325b3599b3455dccdbbda96da5d13cdd..10af9080f2705e3439c9c195d934bf72c3961d22 100644
--- a/GUI/coregui/Models/SessionItemUtils.cpp
+++ b/GUI/coregui/Models/SessionItemUtils.cpp
@@ -34,8 +34,8 @@ const GroupInfoCatalogue& groupInfoCatalogue()
QStringList parents_with_abundance()
{
- return QStringList() << Constants::ParticleCoreShellType << Constants::ParticleCompositionType
- << Constants::ParticleDistributionType << Constants::MesoCrystalType;
+ return QStringList() << "ParticleCoreShell" << "ParticleComposition"
+ << "ParticleDistribution" << "MesoCrystal";
}
} // namespace
@@ -163,7 +163,7 @@ bool SessionItemUtils::IsTheSame(const QVariant& var1, const QVariant& var2)
bool SessionItemUtils::IsPositionRelated(const SessionItem& item)
{
- if (item.modelType() == Constants::PropertyType
+ if (item.modelType() == "Property"
&& (item.displayName() == SessionGraphicsItem::P_XPOS
|| item.displayName() == SessionGraphicsItem::P_YPOS))
return true;
diff --git a/GUI/coregui/Models/SessionXML.cpp b/GUI/coregui/Models/SessionXML.cpp
index a1cf5042161b3f634819cb7cebdf0fbe5ecd8bd7..8c15fc7781584fbbf6e6b2b94c4a73d513fddb3c 100644
--- a/GUI/coregui/Models/SessionXML.cpp
+++ b/GUI/coregui/Models/SessionXML.cpp
@@ -90,14 +90,14 @@ void SessionXML::writeVariant(QXmlStreamWriter* writer, QVariant variant, int ro
QString::number(variant.toBool()));
} else if (type_name == qstring_type_name) {
writer->writeAttribute(SessionXML::ParameterValueAttribute, variant.toString());
- } else if (type_name == Constants::ExternalPropertyType) {
+ } else if (type_name == "ExternalProperty") {
ExternalProperty prop = variant.value<ExternalProperty>();
writer->writeAttribute(SessionXML::ExternalPropertyTextAtt, prop.text());
QString tcol = prop.color().isValid() ? prop.color().name(QColor::HexArgb) : "";
writer->writeAttribute(SessionXML::ExternalPropertyColorAtt, tcol);
writer->writeAttribute(SessionXML::ExternalPropertyIdentifierAtt, prop.identifier());
- } else if (type_name == Constants::ComboPropertyType) {
+ } else if (type_name == "ComboProperty") {
ComboProperty combo = variant.value<ComboProperty>();
writer->writeAttribute(SessionXML::ParameterValueAttribute, combo.stringOfSelections());
writer->writeAttribute(SessionXML::ParameterExtAttribute, combo.stringOfValues());
@@ -193,7 +193,7 @@ QString SessionXML::readProperty(QXmlStreamReader* reader, SessionItem* item,
QString parameter_value =
reader->attributes().value(SessionXML::ParameterValueAttribute).toString();
variant = parameter_value;
- } else if (parameter_type == Constants::ExternalPropertyType) {
+ } else if (parameter_type == "ExternalProperty") {
QString text = reader->attributes().value(SessionXML::ExternalPropertyTextAtt).toString();
QString colorName =
reader->attributes().value(SessionXML::ExternalPropertyColorAtt).toString();
@@ -205,7 +205,7 @@ QString SessionXML::readProperty(QXmlStreamReader* reader, SessionItem* item,
property.setColor(QColor(colorName));
property.setIdentifier(identifier);
variant = property.variant();
- } else if (parameter_type == Constants::ComboPropertyType) {
+ } else if (parameter_type == "ComboProperty") {
QString selections =
reader->attributes().value(SessionXML::ParameterValueAttribute).toString();
QString values = reader->attributes().value(SessionXML::ParameterExtAttribute).toString();
@@ -243,7 +243,7 @@ SessionItem* createItem(SessionItem* item, const QString& modelType, const QStri
{
SessionItem* result(nullptr);
- if (item->modelType() == Constants::GroupItemType) {
+ if (item->modelType() == "GroupProperty") {
if (auto groupItem = dynamic_cast<GroupItem*>(item))
result = groupItem->getItemOfType(modelType);
} else {
diff --git a/GUI/coregui/Models/SimulationOptionsItem.cpp b/GUI/coregui/Models/SimulationOptionsItem.cpp
index 06c8c675dc85e24ba13ab3893d99a60b5ea3637d..0c643275dd95f2a880a59209d8198f869e52a0b7 100644
--- a/GUI/coregui/Models/SimulationOptionsItem.cpp
+++ b/GUI/coregui/Models/SimulationOptionsItem.cpp
@@ -49,7 +49,7 @@ const QString SimulationOptionsItem::P_FRESNEL_MATERIAL_METHOD =
"Material for Fresnel calculations";
const QString SimulationOptionsItem::P_INCLUDE_SPECULAR_PEAK = "Include specular peak";
-SimulationOptionsItem::SimulationOptionsItem() : SessionItem(Constants::SimulationOptionsType)
+SimulationOptionsItem::SimulationOptionsItem() : SessionItem("SimulationOptions")
{
ComboProperty policy;
@@ -62,18 +62,18 @@ SimulationOptionsItem::SimulationOptionsItem() : SessionItem(Constants::Simulati
addProperty(P_NTHREADS, nthreads.variant())->setToolTip(tooltip_nthreads);
ComboProperty computationMethod;
- computationMethod << Constants::SIMULATION_ANALYTICAL << Constants::SIMULATION_MONTECARLO;
+ computationMethod << "Analytical" << "Monte-Carlo Integration";
addProperty(P_COMPUTATION_METHOD, computationMethod.variant())->setToolTip(tooltip_computation);
addProperty(P_MC_POINTS, 100)->setEnabled(false);
ComboProperty averageLayerMaterials;
- averageLayerMaterials << Constants::AMBIENT_LAYER_MATERIAL << Constants::AVERAGE_LAYER_MATERIAL;
+ averageLayerMaterials << "Ambient Layer Material" << "Average Layer Material";
addProperty(P_FRESNEL_MATERIAL_METHOD, averageLayerMaterials.variant())
->setToolTip(tooltip_ambientmaterial);
ComboProperty includeSpecularPeak;
- includeSpecularPeak << Constants::No << Constants::Yes;
+ includeSpecularPeak << "No" << "Yes";
addProperty(P_INCLUDE_SPECULAR_PEAK, includeSpecularPeak.variant())
->setToolTip(tooltip_specularpeak);
@@ -81,7 +81,7 @@ SimulationOptionsItem::SimulationOptionsItem() : SessionItem(Constants::Simulati
if (name == P_COMPUTATION_METHOD && isTag(P_MC_POINTS)) {
ComboProperty combo = getItemValue(P_COMPUTATION_METHOD).value<ComboProperty>();
- if (combo.getValue() == Constants::SIMULATION_ANALYTICAL) {
+ if (combo.getValue() == "Analytical") {
getItem(P_MC_POINTS)->setEnabled(false);
} else {
@@ -103,12 +103,12 @@ int SimulationOptionsItem::getNumberOfThreads() const
bool SimulationOptionsItem::runImmediately() const
{
- return runPolicy() == Constants::JOB_RUN_IMMEDIATELY;
+ return runPolicy() == "Immediately";
}
bool SimulationOptionsItem::runInBackground() const
{
- return runPolicy() == Constants::JOB_RUN_IN_BACKGROUND;
+ return runPolicy() == "In background";
}
void SimulationOptionsItem::setRunPolicy(const QString& policy)
@@ -197,7 +197,7 @@ QStringList SimulationOptionsItem::getCPUUsageOptions()
QStringList SimulationOptionsItem::getRunPolicyNames()
{
QStringList result;
- result << Constants::JOB_RUN_IMMEDIATELY << Constants::JOB_RUN_IN_BACKGROUND;
+ result << "Immediately" << "In background";
return result;
}
diff --git a/GUI/coregui/Models/SpecularBeamInclinationItem.cpp b/GUI/coregui/Models/SpecularBeamInclinationItem.cpp
index 0e21ed9213fe8e2a0a0f2d243b0069e06bf9e29d..9a75c315f277ba9188e4c995b3054817c133590b 100644
--- a/GUI/coregui/Models/SpecularBeamInclinationItem.cpp
+++ b/GUI/coregui/Models/SpecularBeamInclinationItem.cpp
@@ -27,9 +27,9 @@ void setAxisPresentationDefaults(SessionItem* axis_item, const QString& type);
const QString SpecularBeamInclinationItem::P_ALPHA_AXIS = "Alpha axis";
SpecularBeamInclinationItem::SpecularBeamInclinationItem()
- : BeamDistributionItem(Constants::SpecularBeamInclinationType, m_show_mean)
+ : BeamDistributionItem("SpecularBeamInclinationAxis", m_show_mean)
{
- register_distribution_group(Constants::SymmetricDistributionGroup);
+ register_distribution_group("Symmetric distribution group");
setupAxisGroup();
setupDistributionMean(getGroupItem(P_DISTRIBUTION));
@@ -46,24 +46,24 @@ double SpecularBeamInclinationItem::scaleFactor() const
void SpecularBeamInclinationItem::updateFileName(const QString& filename)
{
auto& group_item = item<GroupItem>(P_ALPHA_AXIS);
- auto axis_item = group_item.getChildOfType(Constants::PointwiseAxisType);
+ auto axis_item = group_item.getChildOfType("PointwiseAxis");
axis_item->setItemValue(PointwiseAxisItem::P_FILE_NAME, filename);
}
void SpecularBeamInclinationItem::setupAxisGroup()
{
auto group_item =
- dynamic_cast<GroupItem*>(this->addGroupProperty(P_ALPHA_AXIS, Constants::AxesGroup));
+ dynamic_cast<GroupItem*>(this->addGroupProperty(P_ALPHA_AXIS, "Axes group"));
// Both underlying axis items are created, since it
// strongly simplifies their representation and state
// handling (no signal emulation required).
// Basic axis item is the default one.
- group_item->setCurrentType(Constants::PointwiseAxisType);
+ group_item->setCurrentType("PointwiseAxis");
setAxisPresentationDefaults(group_item->currentItem(), group_item->currentType());
- group_item->setCurrentType(Constants::BasicAxisType);
+ group_item->setCurrentType("BasicAxis");
setAxisPresentationDefaults(group_item->currentItem(), group_item->currentType());
group_item->setToolTip("Axis type selected");
@@ -71,7 +71,7 @@ void SpecularBeamInclinationItem::setupAxisGroup()
group_item->setEnabled(false);
group_item->mapper()->setOnValueChange(
[group_item]() {
- if (group_item->currentItem()->modelType() == Constants::PointwiseAxisType)
+ if (group_item->currentItem()->modelType() == "PointwiseAxis")
group_item->setEnabled(true);
},
this);
@@ -101,11 +101,11 @@ void setAxisPresentationDefaults(SessionItem* axis_item, const QString& type)
axis_item->getItem(BasicAxisItem::P_MIN)->setLimits(RealLimits::limited(0., 90.));
axis_item->getItem(BasicAxisItem::P_MAX)->setLimits(RealLimits::limited(0., 90.));
- if (type == Constants::BasicAxisType) {
+ if (type == "BasicAxis") {
axis_item->setItemValue(BasicAxisItem::P_MIN, 0.0);
axis_item->setItemValue(BasicAxisItem::P_MAX, 3.0);
axis_item->setItemValue(BasicAxisItem::P_NBINS, 500);
- } else if (type == Constants::PointwiseAxisType) {
+ } else if (type == "PointwiseAxis") {
axis_item->getItem(BasicAxisItem::P_MIN)->setEnabled(false);
axis_item->getItem(BasicAxisItem::P_MAX)->setEnabled(false);
axis_item->getItem(BasicAxisItem::P_NBINS)->setEnabled(false);
diff --git a/GUI/coregui/Models/SpecularDataItem.cpp b/GUI/coregui/Models/SpecularDataItem.cpp
index 5dd156cc8e68d1c7eb1a3b37ac548b193fbfbd4c..c97343dead78d67f2cd8a253a6a33f2cb2787676 100644
--- a/GUI/coregui/Models/SpecularDataItem.cpp
+++ b/GUI/coregui/Models/SpecularDataItem.cpp
@@ -23,14 +23,14 @@ const QString SpecularDataItem::P_TITLE = "Title";
const QString SpecularDataItem::P_XAXIS = "x-axis";
const QString SpecularDataItem::P_YAXIS = "y-axis";
-SpecularDataItem::SpecularDataItem() : DataItem(Constants::SpecularDataType)
+SpecularDataItem::SpecularDataItem() : DataItem("SpecularData")
{
addProperty(P_TITLE, QString())->setVisible(false);
- SessionItem* item = addGroupProperty(P_XAXIS, Constants::BasicAxisType);
+ SessionItem* item = addGroupProperty(P_XAXIS, "BasicAxis");
item->getItem(BasicAxisItem::P_NBINS)->setVisible(false);
- item = addGroupProperty(P_YAXIS, Constants::AmplitudeAxisType);
+ item = addGroupProperty(P_YAXIS, "AmplitudeAxis");
item->getItem(BasicAxisItem::P_NBINS)->setVisible(false);
item->getItem(BasicAxisItem::P_TITLE)->setVisible(true);
diff --git a/GUI/coregui/Models/SphericalDetectorItem.cpp b/GUI/coregui/Models/SphericalDetectorItem.cpp
index d9b64f31869e8c0d7e9a3ab7013965362976f857..3b66374979b11586e33d2df1c6f841926f9ccf81 100644
--- a/GUI/coregui/Models/SphericalDetectorItem.cpp
+++ b/GUI/coregui/Models/SphericalDetectorItem.cpp
@@ -20,9 +20,9 @@
const QString SphericalDetectorItem::P_PHI_AXIS = "Phi axis";
const QString SphericalDetectorItem::P_ALPHA_AXIS = "Alpha axis";
-SphericalDetectorItem::SphericalDetectorItem() : DetectorItem(Constants::SphericalDetectorType)
+SphericalDetectorItem::SphericalDetectorItem() : DetectorItem("SphericalDetector")
{
- SessionItem* item = addGroupProperty(P_PHI_AXIS, Constants::BasicAxisType);
+ SessionItem* item = addGroupProperty(P_PHI_AXIS, "BasicAxis");
item->getItem(BasicAxisItem::P_TITLE)->setVisible(false);
item->setItemValue(BasicAxisItem::P_MIN, -1.0);
item->setItemValue(BasicAxisItem::P_MAX, 1.0);
@@ -31,7 +31,7 @@ SphericalDetectorItem::SphericalDetectorItem() : DetectorItem(Constants::Spheric
item->getItem(BasicAxisItem::P_MIN)->setToolTip("Low edge of first phi-bin (in deg)");
item->getItem(BasicAxisItem::P_MAX)->setToolTip("Upper edge of last phi-bin (in deg)");
- item = addGroupProperty(P_ALPHA_AXIS, Constants::BasicAxisType);
+ item = addGroupProperty(P_ALPHA_AXIS, "BasicAxis");
item->getItem(BasicAxisItem::P_TITLE)->setVisible(false);
item->setItemValue(BasicAxisItem::P_MIN, 0.0);
item->setItemValue(BasicAxisItem::P_MAX, 2.0);
diff --git a/GUI/coregui/Models/TransformFromDomain.cpp b/GUI/coregui/Models/TransformFromDomain.cpp
index 902641eb12be188161118cbeda60f2a81ed184e6..6c38dd0f4ac6a10900babb36c840fc12a6f6e954 100644
--- a/GUI/coregui/Models/TransformFromDomain.cpp
+++ b/GUI/coregui/Models/TransformFromDomain.cpp
@@ -191,14 +191,14 @@ void TransformFromDomain::setLayerItem(SessionItem* layerItem, const Layer* laye
const LayerInterface* top_interface)
{
layerItem->setItemValue(LayerItem::P_THICKNESS, layer->thickness());
- layerItem->setGroupProperty(LayerItem::P_ROUGHNESS, Constants::LayerZeroRoughnessType);
+ layerItem->setGroupProperty(LayerItem::P_ROUGHNESS, "LayerZeroRoughness");
layerItem->setItemValue(LayerItem::P_NSLICES, (int)layer->numberOfSlices());
if (top_interface) {
const LayerRoughness* roughness = top_interface->getRoughness();
if (TransformFromDomain::isValidRoughness(roughness)) {
SessionItem* roughnessItem = layerItem->setGroupProperty(
- LayerItem::P_ROUGHNESS, Constants::LayerBasicRoughnessType);
+ LayerItem::P_ROUGHNESS, "LayerBasicRoughness");
TransformFromDomain::setRoughnessItem(roughnessItem, *roughness);
}
}
@@ -336,11 +336,11 @@ void TransformFromDomain::setDetectorGeometry(Instrument2DItem* instrument_item,
const IDetector& detector)
{
if (auto det = dynamic_cast<const SphericalDetector*>(&detector)) {
- instrument_item->setDetectorGroup(Constants::SphericalDetectorType);
+ instrument_item->setDetectorGroup("SphericalDetector");
auto item = dynamic_cast<SphericalDetectorItem*>(instrument_item->detectorItem());
setSphericalDetector(item, *det);
} else if (auto det = dynamic_cast<const RectangularDetector*>(&detector)) {
- instrument_item->setDetectorGroup(Constants::RectangularDetectorType);
+ instrument_item->setDetectorGroup("RectangularDetector");
auto item = dynamic_cast<RectangularDetectorItem*>(instrument_item->detectorItem());
setRectangularDetector(item, *det);
} else {
@@ -361,9 +361,9 @@ void TransformFromDomain::setDetectorResolution(DetectorItem* detector_item,
if (auto resfunc = dynamic_cast<const ResolutionFunction2DGaussian*>(
p_convfunc->getResolutionFunction2D())) {
SessionItem* item = detector_item->setGroupProperty(
- DetectorItem::P_RESOLUTION_FUNCTION, Constants::ResolutionFunction2DGaussianType);
+ DetectorItem::P_RESOLUTION_FUNCTION, "ResolutionFunction2DGaussian");
double scale(1.0);
- if (detector_item->modelType() == Constants::SphericalDetectorType)
+ if (detector_item->modelType() == "SphericalDetector")
scale = 1. / Units::degree;
item->setItemValue(ResolutionFunction2DGaussianItem::P_SIGMA_X,
scale * resfunc->getSigmaX());
@@ -432,7 +432,7 @@ void TransformFromDomain::setRectangularDetector(RectangularDetectorItem* detect
yAxisItem->setItemValue(BasicAxisItem::P_MAX, detector.getHeight());
if (detector.getDetectorArrangment() == RectangularDetector::GENERIC) {
- detector_item->setDetectorAlignment(Constants::ALIGNMENT_GENERIC);
+ detector_item->setDetectorAlignment("Generic");
kvector_t normal = detector.getNormalVector();
SetVectorItem(*detector_item, RectangularDetectorItem::P_NORMAL, normal);
@@ -445,28 +445,28 @@ void TransformFromDomain::setRectangularDetector(RectangularDetectorItem* detect
}
else if (detector.getDetectorArrangment() == RectangularDetector::PERPENDICULAR_TO_SAMPLE) {
- detector_item->setDetectorAlignment(Constants::ALIGNMENT_TO_SAMPLE);
+ detector_item->setDetectorAlignment("Perpendicular to sample x-axis");
detector_item->setItemValue(RectangularDetectorItem::P_DISTANCE, detector.getDistance());
detector_item->setItemValue(RectangularDetectorItem::P_U0, detector.getU0());
detector_item->setItemValue(RectangularDetectorItem::P_V0, detector.getV0());
} else if (detector.getDetectorArrangment()
== RectangularDetector::PERPENDICULAR_TO_DIRECT_BEAM) {
- detector_item->setDetectorAlignment(Constants::ALIGNMENT_TO_DIRECT_BEAM);
+ detector_item->setDetectorAlignment("Perpendicular to direct beam");
detector_item->setItemValue(RectangularDetectorItem::P_DISTANCE, detector.getDistance());
detector_item->setItemValue(RectangularDetectorItem::P_DBEAM_U0, detector.getU0());
detector_item->setItemValue(RectangularDetectorItem::P_DBEAM_V0, detector.getV0());
} else if (detector.getDetectorArrangment()
== RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM) {
- detector_item->setDetectorAlignment(Constants::ALIGNMENT_TO_REFLECTED_BEAM);
+ detector_item->setDetectorAlignment("Perpendicular to reflected beam");
detector_item->setItemValue(RectangularDetectorItem::P_DISTANCE, detector.getDistance());
detector_item->setItemValue(RectangularDetectorItem::P_U0, detector.getU0());
detector_item->setItemValue(RectangularDetectorItem::P_V0, detector.getV0());
} else if (detector.getDetectorArrangment()
== RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM_DPOS) {
- detector_item->setDetectorAlignment(Constants::ALIGNMENT_TO_REFLECTED_BEAM_DPOS);
+ detector_item->setDetectorAlignment("Perpendicular to reflected beam (dpos)");
detector_item->setItemValue(RectangularDetectorItem::P_DISTANCE, detector.getDistance());
detector_item->setItemValue(RectangularDetectorItem::P_DBEAM_U0,
detector.getDirectBeamU0());
@@ -489,7 +489,7 @@ void TransformFromDomain::setDetectorMasks(DetectorItem* detector_item,
detector_item->createMaskContainer();
double scale(1.0);
- if (detector_item->modelType() == Constants::SphericalDetectorType)
+ if (detector_item->modelType() == "SphericalDetector")
scale = 1. / Units::degree;
setMaskContainer(detector_item->maskContainerItem(), *detector, scale);
@@ -605,12 +605,12 @@ void TransformFromDomain::setBackground(InstrumentItem* instrument_item,
auto p_bg = simulation.background();
if (auto p_constant_bg = dynamic_cast<const ConstantBackground*>(p_bg)) {
auto constant_bg_item = instrument_item->setGroupProperty(
- InstrumentItem::P_BACKGROUND, Constants::ConstantBackgroundType);
+ InstrumentItem::P_BACKGROUND, "ConstantBackground");
double value = p_constant_bg->backgroundValue();
constant_bg_item->setItemValue(ConstantBackgroundItem::P_VALUE, value);
} else if (dynamic_cast<const PoissonNoiseBackground*>(p_bg)) {
instrument_item->setGroupProperty(InstrumentItem::P_BACKGROUND,
- Constants::PoissonNoiseBackgroundType);
+ "PoissonNoiseBackground");
}
}
@@ -621,12 +621,12 @@ void TransformFromDomain::setFootprintFactor(const IFootprintFactor* footprint,
return;
if (const auto gaussian_fp = dynamic_cast<const FootprintFactorGaussian*>(footprint)) {
auto gaussian_fp_item = beam_item->setGroupProperty(SpecularBeamItem::P_FOOPTPRINT,
- Constants::FootprintGaussianType);
+ "GaussianFootrpint");
const double value = gaussian_fp->widthRatio();
gaussian_fp_item->setItemValue(FootprintGaussianItem::P_VALUE, value);
} else if (const auto square_fp = dynamic_cast<const FootprintFactorSquare*>(footprint)) {
auto square_fp_item = beam_item->setGroupProperty(SpecularBeamItem::P_FOOPTPRINT,
- Constants::FootprintSquareType);
+ "SquareFootprint");
const double value = square_fp->widthRatio();
square_fp_item->setItemValue(FootprintSquareItem::P_VALUE, value);
}
@@ -634,7 +634,7 @@ void TransformFromDomain::setFootprintFactor(const IFootprintFactor* footprint,
void TransformFromDomain::setAxisItem(SessionItem* item, const IAxis& axis, double factor)
{
- if (item->modelType() != Constants::BasicAxisType)
+ if (item->modelType() != "BasicAxis")
throw GUIHelpers::Error("TransformFromDomain::setAxisItem() -> Error. Unexpected item.");
if (!dynamic_cast<const FixedBinAxis*>(&axis))
@@ -652,31 +652,31 @@ void SetPDF1D(SessionItem* item, const IFTDistribution1D* ipdf, QString group_na
{
if (const FTDistribution1DCauchy* pdf = dynamic_cast<const FTDistribution1DCauchy*>(ipdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDistribution1DCauchyType);
+ item->setGroupProperty(group_name, "FTDistribution1DCauchy");
pdfItem->setItemValue(FTDistribution1DCauchyItem::P_OMEGA, pdf->omega());
} else if (const FTDistribution1DGauss* pdf =
dynamic_cast<const FTDistribution1DGauss*>(ipdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDistribution1DGaussType);
+ item->setGroupProperty(group_name, "FTDistribution1DGauss");
pdfItem->setItemValue(FTDistribution1DGaussItem::P_OMEGA, pdf->omega());
} else if (const FTDistribution1DGate* pdf = dynamic_cast<const FTDistribution1DGate*>(ipdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDistribution1DGateType);
+ item->setGroupProperty(group_name, "FTDistribution1DGate");
pdfItem->setItemValue(FTDistribution1DGateItem::P_OMEGA, pdf->omega());
} else if (const FTDistribution1DTriangle* pdf =
dynamic_cast<const FTDistribution1DTriangle*>(ipdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDistribution1DTriangleType);
+ item->setGroupProperty(group_name, "FTDistribution1DTriangle");
pdfItem->setItemValue(FTDistribution1DTriangleItem::P_OMEGA, pdf->omega());
} else if (const FTDistribution1DCosine* pdf =
dynamic_cast<const FTDistribution1DCosine*>(ipdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDistribution1DCosineType);
+ item->setGroupProperty(group_name, "FTDistribution1DCosine");
pdfItem->setItemValue(FTDistribution1DCosineItem::P_OMEGA, pdf->omega());
} else if (const FTDistribution1DVoigt* pdf =
dynamic_cast<const FTDistribution1DVoigt*>(ipdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDistribution1DVoigtType);
+ item->setGroupProperty(group_name, "FTDistribution1DVoigt");
pdfItem->setItemValue(FTDistribution1DVoigtItem::P_OMEGA, pdf->omega());
pdfItem->setItemValue(FTDistribution1DVoigtItem::P_ETA, pdf->eta());
} else {
@@ -689,7 +689,7 @@ void setPDF2D(SessionItem* item, const IFTDistribution2D* pdf, QString group_nam
if (const FTDistribution2DCauchy* pdf_cauchy =
dynamic_cast<const FTDistribution2DCauchy*>(pdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDistribution2DCauchyType);
+ item->setGroupProperty(group_name, "FTDistribution2DCauchy");
pdfItem->setItemValue(FTDistribution2DCauchyItem::P_OMEGA_X, pdf_cauchy->omegaX());
pdfItem->setItemValue(FTDistribution2DCauchyItem::P_OMEGA_Y, pdf_cauchy->omegaY());
pdfItem->setItemValue(FTDistribution2DCauchyItem::P_GAMMA,
@@ -697,7 +697,7 @@ void setPDF2D(SessionItem* item, const IFTDistribution2D* pdf, QString group_nam
} else if (const FTDistribution2DGauss* pdf_gauss =
dynamic_cast<const FTDistribution2DGauss*>(pdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDistribution2DGaussType);
+ item->setGroupProperty(group_name, "FTDistribution2DGauss");
pdfItem->setItemValue(FTDistribution2DGaussItem::P_OMEGA_X, pdf_gauss->omegaX());
pdfItem->setItemValue(FTDistribution2DGaussItem::P_OMEGA_Y, pdf_gauss->omegaY());
pdfItem->setItemValue(FTDistribution2DGaussItem::P_GAMMA,
@@ -705,21 +705,21 @@ void setPDF2D(SessionItem* item, const IFTDistribution2D* pdf, QString group_nam
} else if (const FTDistribution2DGate* pdf_gate =
dynamic_cast<const FTDistribution2DGate*>(pdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDistribution2DGateType);
+ item->setGroupProperty(group_name, "FTDistribution2DGate");
pdfItem->setItemValue(FTDistribution2DGateItem::P_OMEGA_X, pdf_gate->omegaX());
pdfItem->setItemValue(FTDistribution2DGateItem::P_OMEGA_Y, pdf_gate->omegaY());
pdfItem->setItemValue(FTDistribution2DGateItem::P_GAMMA, Units::rad2deg(pdf_gate->gamma()));
} else if (const FTDistribution2DCone* pdf_cone =
dynamic_cast<const FTDistribution2DCone*>(pdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDistribution2DConeType);
+ item->setGroupProperty(group_name, "FTDistribution2DCone");
pdfItem->setItemValue(FTDistribution2DConeItem::P_OMEGA_X, pdf_cone->omegaX());
pdfItem->setItemValue(FTDistribution2DConeItem::P_OMEGA_Y, pdf_cone->omegaY());
pdfItem->setItemValue(FTDistribution2DConeItem::P_GAMMA, Units::rad2deg(pdf_cone->gamma()));
} else if (const FTDistribution2DVoigt* pdf_voigt =
dynamic_cast<const FTDistribution2DVoigt*>(pdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDistribution2DVoigtType);
+ item->setGroupProperty(group_name, "FTDistribution2DVoigt");
pdfItem->setItemValue(FTDistribution2DVoigtItem::P_OMEGA_X, pdf_voigt->omegaX());
pdfItem->setItemValue(FTDistribution2DVoigtItem::P_OMEGA_Y, pdf_voigt->omegaY());
pdfItem->setItemValue(FTDistribution2DVoigtItem::P_GAMMA,
@@ -734,22 +734,22 @@ void SetDecayFunction1D(SessionItem* item, const IFTDecayFunction1D* ipdf, QStri
{
if (const FTDecayFunction1DCauchy* pdf = dynamic_cast<const FTDecayFunction1DCauchy*>(ipdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDecayFunction1DCauchyType);
+ item->setGroupProperty(group_name, "FTDecayFunction1DCauchy");
pdfItem->setItemValue(FTDecayFunction1DItem::P_DECAY_LENGTH, pdf->decayLength());
} else if (const FTDecayFunction1DGauss* pdf =
dynamic_cast<const FTDecayFunction1DGauss*>(ipdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDecayFunction1DGaussType);
+ item->setGroupProperty(group_name, "FTDecayFunction1DGauss");
pdfItem->setItemValue(FTDecayFunction1DItem::P_DECAY_LENGTH, pdf->decayLength());
} else if (const FTDecayFunction1DTriangle* pdf =
dynamic_cast<const FTDecayFunction1DTriangle*>(ipdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDecayFunction1DTriangleType);
+ item->setGroupProperty(group_name, "FTDecayFunction1DTriangle");
pdfItem->setItemValue(FTDecayFunction1DItem::P_DECAY_LENGTH, pdf->decayLength());
} else if (const FTDecayFunction1DVoigt* pdf =
dynamic_cast<const FTDecayFunction1DVoigt*>(ipdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDecayFunction1DVoigtType);
+ item->setGroupProperty(group_name, "FTDecayFunction1DVoigt");
pdfItem->setItemValue(FTDecayFunction1DItem::P_DECAY_LENGTH, pdf->decayLength());
pdfItem->setItemValue(FTDecayFunction1DVoigtItem::P_ETA, pdf->eEta());
} else {
@@ -762,21 +762,21 @@ void SetDecayFunction2D(SessionItem* item, const IFTDecayFunction2D* pdf, QStrin
if (const FTDecayFunction2DCauchy* pdf_cauchy =
dynamic_cast<const FTDecayFunction2DCauchy*>(pdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDecayFunction2DCauchyType);
+ item->setGroupProperty(group_name, "FTDecayFunction2DCauchy");
pdfItem->setItemValue(FTDecayFunction2DItem::P_DECAY_LENGTH_X, pdf_cauchy->decayLengthX());
pdfItem->setItemValue(FTDecayFunction2DItem::P_DECAY_LENGTH_Y, pdf_cauchy->decayLengthY());
pdfItem->setItemValue(FTDecayFunction2DItem::P_GAMMA, Units::rad2deg(pdf_cauchy->gamma()));
} else if (const FTDecayFunction2DGauss* pdf_gauss =
dynamic_cast<const FTDecayFunction2DGauss*>(pdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDecayFunction2DGaussType);
+ item->setGroupProperty(group_name, "FTDecayFunction2DGauss");
pdfItem->setItemValue(FTDecayFunction2DItem::P_DECAY_LENGTH_X, pdf_gauss->decayLengthX());
pdfItem->setItemValue(FTDecayFunction2DItem::P_DECAY_LENGTH_Y, pdf_gauss->decayLengthY());
pdfItem->setItemValue(FTDecayFunction2DItem::P_GAMMA, Units::rad2deg(pdf_gauss->gamma()));
} else if (const FTDecayFunction2DVoigt* pdf_voigt =
dynamic_cast<const FTDecayFunction2DVoigt*>(pdf)) {
SessionItem* pdfItem =
- item->setGroupProperty(group_name, Constants::FTDecayFunction2DVoigtType);
+ item->setGroupProperty(group_name, "FTDecayFunction2DVoigt");
pdfItem->setItemValue(FTDecayFunction2DItem::P_DECAY_LENGTH_X, pdf_voigt->decayLengthX());
pdfItem->setItemValue(FTDecayFunction2DItem::P_DECAY_LENGTH_Y, pdf_voigt->decayLengthY());
pdfItem->setItemValue(FTDecayFunction2DItem::P_GAMMA, Units::rad2deg(pdf_voigt->gamma()));
@@ -791,17 +791,17 @@ void set2DLatticeParameters(SessionItem* item, const Lattice2D& lattice)
SessionItem* latticeItem(nullptr);
if (lattice.getName() == "SquareLattice") {
latticeItem = item->setGroupProperty(InterferenceFunction2DLatticeItem::P_LATTICE_TYPE,
- Constants::SquareLatticeType);
+ "SquareLattice");
latticeItem->setItemValue(SquareLatticeItem::P_LATTICE_LENGTH, lattice.length1());
} else if (lattice.getName() == "HexagonalLattice") {
latticeItem = item->setGroupProperty(InterferenceFunction2DLatticeItem::P_LATTICE_TYPE,
- Constants::HexagonalLatticeType);
+ "HexagonalLattice");
latticeItem->setItemValue(HexagonalLatticeItem::P_LATTICE_LENGTH, lattice.length1());
} else {
latticeItem = item->setGroupProperty(InterferenceFunction2DLatticeItem::P_LATTICE_TYPE,
- Constants::BasicLatticeType);
+ "BasicLattice");
latticeItem->setItemValue(BasicLatticeItem::P_LATTICE_LENGTH1, lattice.length1());
latticeItem->setItemValue(BasicLatticeItem::P_LATTICE_LENGTH2, lattice.length2());
latticeItem->setItemValue(BasicLatticeItem::P_LATTICE_ANGLE,
@@ -824,32 +824,32 @@ void setDistribution(SessionItem* part_distr_item, ParameterDistribution par_dis
SessionItem* item = 0;
if (const DistributionGate* distr = dynamic_cast<const DistributionGate*>(p_distribution)) {
- item = part_distr_item->setGroupProperty(group_name, Constants::DistributionGateType);
+ item = part_distr_item->setGroupProperty(group_name, "DistributionGate");
item->setItemValue(DistributionGateItem::P_MIN, factor * distr->getMin());
item->setItemValue(DistributionGateItem::P_MAX, factor * distr->getMax());
} else if (const DistributionLorentz* distr =
dynamic_cast<const DistributionLorentz*>(p_distribution)) {
- item = part_distr_item->setGroupProperty(group_name, Constants::DistributionLorentzType);
+ item = part_distr_item->setGroupProperty(group_name, "DistributionLorentz");
item->setItemValue(DistributionLorentzItem::P_MEAN, factor * distr->getMean());
item->setItemValue(DistributionLorentzItem::P_HWHM, factor * distr->getHWHM());
} else if (const DistributionGaussian* distr =
dynamic_cast<const DistributionGaussian*>(p_distribution)) {
- item = part_distr_item->setGroupProperty(group_name, Constants::DistributionGaussianType);
+ item = part_distr_item->setGroupProperty(group_name, "DistributionGaussian");
item->setItemValue(DistributionGaussianItem::P_MEAN, factor * distr->getMean());
item->setItemValue(DistributionGaussianItem::P_STD_DEV, factor * distr->getStdDev());
} else if (const DistributionLogNormal* distr =
dynamic_cast<const DistributionLogNormal*>(p_distribution)) {
- item = part_distr_item->setGroupProperty(group_name, Constants::DistributionLogNormalType);
+ item = part_distr_item->setGroupProperty(group_name, "DistributionLogNormal");
item->setItemValue(DistributionLogNormalItem::P_MEDIAN, factor * distr->getMedian());
item->setItemValue(DistributionLogNormalItem::P_SCALE_PAR, distr->getScalePar());
} else if (const DistributionCosine* distr =
dynamic_cast<const DistributionCosine*>(p_distribution)) {
- item = part_distr_item->setGroupProperty(group_name, Constants::DistributionCosineType);
+ item = part_distr_item->setGroupProperty(group_name, "DistributionCosine");
item->setItemValue(DistributionCosineItem::P_MEAN, factor * distr->getMean());
item->setItemValue(DistributionCosineItem::P_SIGMA, factor * distr->getSigma());
} else if (const DistributionTrapezoid* distr =
dynamic_cast<const DistributionTrapezoid*>(p_distribution)) {
- item = part_distr_item->setGroupProperty(group_name, Constants::DistributionTrapezoidType);
+ item = part_distr_item->setGroupProperty(group_name, "DistributionTrapezoid");
item->setItemValue(DistributionTrapezoidItem::P_CENTER, factor * distr->getMean());
item->setItemValue(DistributionTrapezoidItem::P_LEFTWIDTH, factor * distr->getLeftWidth());
item->setItemValue(DistributionTrapezoidItem::P_MIDDLEWIDTH,
diff --git a/GUI/coregui/Models/TransformToDomain.cpp b/GUI/coregui/Models/TransformToDomain.cpp
index bc68a967284c0fe4c373740395a922292eebce6d..c087330b7320c44e8b8aaae3c196a274edadad6d 100644
--- a/GUI/coregui/Models/TransformToDomain.cpp
+++ b/GUI/coregui/Models/TransformToDomain.cpp
@@ -99,9 +99,9 @@ std::unique_ptr<Layer> TransformToDomain::createLayer(const SessionItem& item)
std::unique_ptr<LayerRoughness>
TransformToDomain::createLayerRoughness(const SessionItem& roughnessItem)
{
- if (roughnessItem.modelType() == Constants::LayerZeroRoughnessType) {
+ if (roughnessItem.modelType() == "LayerZeroRoughness") {
return nullptr;
- } else if (roughnessItem.modelType() == Constants::LayerBasicRoughnessType) {
+ } else if (roughnessItem.modelType() == "LayerBasicRoughness") {
return std::make_unique<LayerRoughness>(
roughnessItem.getItemValue(LayerBasicRoughnessItem::P_SIGMA).toDouble(),
roughnessItem.getItemValue(LayerBasicRoughnessItem::P_HURST).toDouble(),
@@ -124,16 +124,16 @@ std::unique_ptr<ParticleLayout> TransformToDomain::createParticleLayout(const Se
std::unique_ptr<IParticle> TransformToDomain::createIParticle(const SessionItem& item)
{
std::unique_ptr<IParticle> P_particle;
- if (item.modelType() == Constants::ParticleType) {
+ if (item.modelType() == "Particle") {
auto& particle_item = static_cast<const ParticleItem&>(item);
P_particle = particle_item.createParticle();
- } else if (item.modelType() == Constants::ParticleCoreShellType) {
+ } else if (item.modelType() == "ParticleCoreShell") {
auto& particle_coreshell_item = static_cast<const ParticleCoreShellItem&>(item);
P_particle = particle_coreshell_item.createParticleCoreShell();
- } else if (item.modelType() == Constants::ParticleCompositionType) {
+ } else if (item.modelType() == "ParticleComposition") {
auto& particle_composition_item = static_cast<const ParticleCompositionItem&>(item);
P_particle = particle_composition_item.createParticleComposition();
- } else if (item.modelType() == Constants::MesoCrystalType) {
+ } else if (item.modelType() == "MesoCrystal") {
auto& mesocrystal_item = static_cast<const MesoCrystalItem&>(item);
P_particle = mesocrystal_item.createMesoCrystal();
}
@@ -152,8 +152,8 @@ TransformToDomain::createParticleDistribution(const SessionItem& item)
void TransformToDomain::addDistributionParametersToSimulation(const SessionItem& beam_item,
GISASSimulation& simulation)
{
- if (beam_item.modelType() != Constants::GISASBeamType) {
- Q_ASSERT(beam_item.modelType() == Constants::GISASBeamType);
+ if (beam_item.modelType() != "GISASBeam") {
+ Q_ASSERT(beam_item.modelType() == "GISASBeam");
return;
}
@@ -168,8 +168,8 @@ void TransformToDomain::addDistributionParametersToSimulation(const SessionItem&
void TransformToDomain::addBeamDivergencesToScan(const SessionItem& beam_item,
AngularSpecScan& scan)
{
- if (beam_item.modelType() != Constants::SpecularBeamType) {
- Q_ASSERT(beam_item.modelType() == Constants::SpecularBeamType);
+ if (beam_item.modelType() != "SpecularBeam") {
+ Q_ASSERT(beam_item.modelType() == "SpecularBeam");
return;
}
@@ -195,17 +195,17 @@ void TransformToDomain::setBeamDistribution(const std::string& parameter_name,
void TransformToDomain::setSimulationOptions(Simulation* simulation, const SessionItem& item)
{
- Q_ASSERT(item.modelType() == Constants::SimulationOptionsType);
+ Q_ASSERT(item.modelType() == "SimulationOptions");
if (auto optionItem = dynamic_cast<const SimulationOptionsItem*>(&item)) {
simulation->getOptions().setNumberOfThreads(optionItem->getNumberOfThreads());
- if (optionItem->getComputationMethod() == Constants::SIMULATION_MONTECARLO) {
+ if (optionItem->getComputationMethod() == "Monte-Carlo Integration") {
simulation->getOptions().setMonteCarloIntegration(
true, optionItem->getNumberOfMonteCarloPoints());
}
- if (optionItem->getFresnelMaterialMethod() == Constants::AVERAGE_LAYER_MATERIAL)
+ if (optionItem->getFresnelMaterialMethod() == "Average Layer Material")
simulation->getOptions().setUseAvgMaterials(true);
- if (optionItem->getIncludeSpecularPeak() == Constants::Yes)
+ if (optionItem->getIncludeSpecularPeak() == "Yes")
simulation->getOptions().setIncludeSpecular(true);
}
}
@@ -226,7 +226,7 @@ void TransformToDomain::setRotationInfo(IParticle* result, const SessionItem& it
{
QVector<SessionItem*> children = item.children();
for (int i = 0; i < children.size(); ++i) {
- if (children[i]->modelType() == Constants::RotationType) {
+ if (children[i]->modelType() == "Rotation") {
auto& rot_item = children[i]->groupItem<RotationItem>(TransformationItem::P_ROT);
auto rotation = rot_item.createRotation();
if (rotation)
diff --git a/GUI/coregui/Models/TransformationItem.cpp b/GUI/coregui/Models/TransformationItem.cpp
index 8e0bc4ec9609e0a96325b6aaeb097b9f8c36b869..d81b9ed655f5e1b14c4444d6099e3f8ca66c6fc4 100644
--- a/GUI/coregui/Models/TransformationItem.cpp
+++ b/GUI/coregui/Models/TransformationItem.cpp
@@ -16,8 +16,8 @@
const QString TransformationItem::P_ROT = "Rotation type";
-TransformationItem::TransformationItem() : SessionGraphicsItem(Constants::RotationType)
+TransformationItem::TransformationItem() : SessionGraphicsItem("Rotation")
{
setToolTip(QStringLiteral("Rotation applied to particles"));
- addGroupProperty(P_ROT, Constants::RotationGroup);
+ addGroupProperty(P_ROT, "Rotation group");
}
diff --git a/GUI/coregui/Models/VectorItem.cpp b/GUI/coregui/Models/VectorItem.cpp
index 7e49179acac9911026141e62c9aac666f5863c1c..3e910d59d568ee68f6b05ce0791eacce5e323768 100644
--- a/GUI/coregui/Models/VectorItem.cpp
+++ b/GUI/coregui/Models/VectorItem.cpp
@@ -18,7 +18,7 @@ const QString VectorItem::P_X = "X";
const QString VectorItem::P_Y = "Y";
const QString VectorItem::P_Z = "Z";
-VectorItem::VectorItem() : SessionItem(Constants::VectorType)
+VectorItem::VectorItem() : SessionItem("Vector")
{
addProperty(P_X, 0.0)
->setLimits(RealLimits::limitless())
diff --git a/GUI/coregui/Models/item_constants.h b/GUI/coregui/Models/item_constants.h
deleted file mode 100644
index 75ef1b6f4df93ca4d88392f4550922a812fd10f1..0000000000000000000000000000000000000000
--- a/GUI/coregui/Models/item_constants.h
+++ /dev/null
@@ -1,315 +0,0 @@
-// ************************************************************************** //
-//
-// BornAgain: simulate and fit scattering at grazing incidence
-//
-//! @file GUI/coregui/Models/item_constants.h
-//! @brief Defines item constants
-//!
-//! @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)
-//
-// ************************************************************************** //
-
-#ifndef BORNAGAIN_GUI_COREGUI_MODELS_ITEM_CONSTANTS_H
-#define BORNAGAIN_GUI_COREGUI_MODELS_ITEM_CONSTANTS_H
-
-#include <QString>
-
-namespace Constants
-{
-
-// --- Items -------------------------------------------------------------------
-
-const QString Yes = "Yes";
-const QString No = "No";
-
-const QString RootItemType = "ROOT_ITEM";
-
-const QString LayerType = "Layer";
-const QString MesoCrystalType = "MesoCrystal";
-const QString MultiLayerType = "MultiLayer";
-const QString ParticleType = "Particle";
-const QString ParticleLayoutType = "ParticleLayout";
-const QString ParticleCoreShellType = "ParticleCoreShell";
-const QString ParticleDistributionType = "ParticleDistribution";
-const QString ParticleCompositionType = "ParticleComposition";
-const QString RotationType = "Rotation";
-const QString InterferenceFunction1DLatticeType = "Interference1DLattice";
-const QString InterferenceFunction2DLatticeType = "Interference2DLattice";
-const QString InterferenceFunction2DParaCrystalType = "Interference2DParaCrystal";
-const QString InterferenceFunctionFinite2DLatticeType = "InterferenceFinite2DLattice";
-const QString InterferenceFunctionHardDiskType = "InterferenceHardDisk";
-const QString InterferenceFunctionRadialParaCrystalType = "InterferenceRadialParaCrystal";
-const QString GISASInstrumentType = "GISASInstrument";
-const QString OffSpecInstrumentType = "OffSpecInstrument";
-const QString SpecularInstrumentType = "SpecularInstrument";
-const QString DepthProbeInstrumentType = "DepthProbeInstrument";
-const QString GISASBeamType = "GISASBeam";
-const QString SpecularBeamType = "SpecularBeam";
-
-const QString FormFactorType = "FormFactor";
-const QString AnisoPyramidType = "AnisoPyramid";
-const QString BarGaussType = "BarGauss";
-const QString BarLorentzType = "BarLorentz";
-const QString BoxType = "Box";
-const QString ConeType = "Cone";
-const QString Cone6Type = "Cone6";
-const QString CuboctahedronType = "Cuboctahedron";
-const QString CylinderType = "Cylinder";
-const QString DodecahedronType = "Dodecahedron";
-const QString DotType = "Dot";
-const QString EllipsoidalCylinderType = "EllipsoidalCylinder";
-const QString FullSphereType = "FullSphere";
-const QString FullSpheroidType = "FullSpheroid";
-const QString HemiEllipsoidType = "HemiEllipsoid";
-const QString IcosahedronType = "Icosahedron";
-const QString Prism3Type = "Prism3";
-const QString Prism6Type = "Prism6";
-const QString PyramidType = "Pyramid";
-const QString Ripple1BoxType = "Ripple1Box";
-const QString Ripple1GaussType = "Ripple1Gauss";
-const QString Ripple1LorentzType = "Ripple1Lorentz";
-const QString Ripple2BoxType = "Ripple2Box";
-const QString Ripple2GaussType = "Ripple2Gauss";
-const QString Ripple2LorentzType = "Ripple2Lorentz";
-const QString TetrahedronType = "Tetrahedron";
-const QString TruncatedCubeType = "TruncatedCube";
-const QString TruncatedSphereType = "TruncatedSphere";
-const QString TruncatedSpheroidType = "TruncatedSpheroid";
-
-const QString XRotationType = "XRotation";
-const QString YRotationType = "YRotation";
-const QString ZRotationType = "ZRotation";
-const QString EulerRotationType = "EulerRotation";
-
-const QString PropertyType = "Property";
-const QString VectorType = "Vector";
-const QString GroupItemType = "GroupProperty";
-
-const QString LayerBasicRoughnessType = "LayerBasicRoughness";
-const QString LayerZeroRoughnessType = "LayerZeroRoughness";
-
-const QString SphericalDetectorType = "SphericalDetector";
-const QString RectangularDetectorType = "RectangularDetector";
-
-const QString DistributionNoneType = "DistributionNone";
-const QString DistributionGateType = "DistributionGate";
-const QString DistributionLorentzType = "DistributionLorentz";
-const QString DistributionGaussianType = "DistributionGaussian";
-const QString DistributionLogNormalType = "DistributionLogNormal";
-const QString DistributionCosineType = "DistributionCosine";
-const QString DistributionTrapezoidType = "DistributionTrapezoid";
-
-const QString FTDistribution1DCauchyType = "FTDistribution1DCauchy";
-const QString FTDistribution1DGaussType = "FTDistribution1DGauss";
-const QString FTDistribution1DGateType = "FTDistribution1DGate";
-const QString FTDistribution1DTriangleType = "FTDistribution1DTriangle";
-const QString FTDistribution1DCosineType = "FTDistribution1DCosine";
-const QString FTDistribution1DVoigtType = "FTDistribution1DVoigt";
-
-const QString FTDistribution2DCauchyType = "FTDistribution2DCauchy";
-const QString FTDistribution2DGaussType = "FTDistribution2DGauss";
-const QString FTDistribution2DGateType = "FTDistribution2DGate";
-const QString FTDistribution2DConeType = "FTDistribution2DCone";
-const QString FTDistribution2DVoigtType = "FTDistribution2DVoigt";
-
-const QString FTDecayFunction1DCauchyType = "FTDecayFunction1DCauchy";
-const QString FTDecayFunction1DGaussType = "FTDecayFunction1DGauss";
-const QString FTDecayFunction1DTriangleType = "FTDecayFunction1DTriangle";
-const QString FTDecayFunction1DVoigtType = "FTDecayFunction1DVoigt";
-
-const QString FTDecayFunction2DCauchyType = "FTDecayFunction2DCauchy";
-const QString FTDecayFunction2DGaussType = "FTDecayFunction2DGauss";
-const QString FTDecayFunction2DVoigtType = "FTDecayFunction2DVoigt";
-
-const QString BasicLatticeType = "BasicLattice";
-const QString SquareLatticeType = "SquareLattice";
-const QString HexagonalLatticeType = "HexagonalLattice";
-
-const QString MaterialType = "Material";
-const QString MaterialContainerType = "MaterialContainer";
-
-const QString MaterialRefractiveDataType = "MaterialRefractiveData";
-const QString MaterialSLDDataType = "MaterialSLDData";
-
-const QString MagneticFieldType = "MagneticField";
-
-const QString ParameterContainerType = "Parameter Container";
-const QString ParameterType = "Parameter";
-const QString ParameterLabelType = "Parameter Label";
-
-const QString FitParameterContainerType = "FitParameterContainer";
-const QString FitParameterType = "FitParameter";
-const QString FitParameterLinkType = "FitParameterLink";
-const QString FitSuiteType = "FitSuite";
-
-const QString JobItemType = "JobItem";
-const QString IntensityDataType = "IntensityData";
-const QString SpecularDataType = "SpecularData";
-const QString Data1DViewItemType = "Data1DViewItem";
-const QString DataPropertyContainerType = "DataPropertyContainer";
-const QString DataItem1DPropertiesType = "DataItem1DProperties";
-
-const QString BasicAxisType = "BasicAxis";
-const QString PointwiseAxisType = "PointwiseAxis";
-const QString AmplitudeAxisType = "AmplitudeAxis";
-
-const QString BeamDistributionType = "BeamDistribution";
-const QString BeamWavelengthType = "BeamWavelength";
-const QString BeamAzimuthalAngleType = "BeamAzimuthalAngle";
-const QString BeamInclinationAngleType = "BeamInclinationAngle";
-const QString SpecularBeamInclinationType = "SpecularBeamInclinationAxis";
-const QString SpecularBeamWavelengthType = "SpecularBeamWavelength";
-
-const QString ResolutionFunctionNoneType = "ResolutionFunctionNone";
-const QString ResolutionFunction2DGaussianType = "ResolutionFunction2DGaussian";
-
-const QString MaskContainerType = "MaskContainer";
-const QString RectangleMaskType = "RectangleMask";
-const QString PolygonMaskType = "PolygonMask";
-const QString PolygonPointType = "PolygonPoint";
-const QString EllipseMaskType = "EllipseMask";
-const QString VerticalLineMaskType = "VerticalLineMask";
-const QString HorizontalLineMaskType = "HorizontalLineMask";
-const QString MaskAllType = "MaskAllMask";
-
-const QString RegionOfInterestType = "RegionOfInterest";
-
-const QString SimulationOptionsType = "SimulationOptions";
-
-const QString RealDataType = "RealData";
-
-const QString MinimizerContainerType = "MinimizerContainer";
-const QString MinuitMinimizerType = "Minuit2";
-const QString GSLMultiMinimizerType = "GSLMultiMin";
-const QString GSLLMAMinimizerType = "GSLLMA";
-const QString GSLSimAnMinimizerType = "GSLSimAn";
-const QString GeneticMinimizerType = "Genetic";
-const QString TestMinimizerType = "Test";
-
-const QString RealLimitsLimitlessType = "RealLimitsLimitless";
-const QString RealLimitsPositiveType = "RealLimitsPositive";
-const QString RealLimitsNonnegativeType = "RealLimitsNonnegative";
-const QString RealLimitsLowerLimitedType = "RealLimitsLowerLimited";
-const QString RealLimitsUpperLimitedType = "RealLimitsUpperLimited";
-const QString RealLimitsLimitedType = "RealLimitsLimited";
-
-const QString ProjectionContainerType = "ProjectionContainer";
-
-const QString BackgroundNoneType = "NoBackground";
-const QString ConstantBackgroundType = "ConstantBackground";
-const QString PoissonNoiseBackgroundType = "PoissonNoiseBackground";
-
-const QString FootprintNoneType = "NoFootprint";
-const QString FootprintGaussianType = "GaussianFootrpint";
-const QString FootprintSquareType = "SquareFootprint";
-
-const QString VarianceConstantFunctionType = "VarianceConstantFunction";
-const QString VarianceSimFunctionType = "VarianceSimFunction";
-
-// --- Groups ------------------------------------------------------------------
-
-const QString FormFactorGroup = "Form Factor";
-const QString RotationGroup = "Rotation group";
-const QString LayerRoughnessGroup = "Roughness";
-const QString DetectorGroup = "Detector group";
-const QString DistributionGroup = "Distribution group";
-const QString DistributionExtendedGroup = "Distribution extended group";
-const QString SymmetricDistributionGroup = "Symmetric distribution group";
-const QString FTDistribution1DGroup = "PDF 1D";
-const QString FTDistribution2DGroup = "PDF 2D";
-const QString FTDecayFunction1DGroup = "Decay function 1D";
-const QString FTDecayFunction2DGroup = "Decay function 2D";
-const QString LatticeGroup = "Lattice group";
-const QString MaterialGroup = "Material group";
-const QString ResolutionFunctionGroup = "Resolution function group";
-const QString MinimizerLibraryGroup = "Minimizer library group";
-const QString RealLimitsGroup = "RealLimits group";
-const QString BackgroundGroup = "Background group";
-const QString MaterialDataGroup = "Material data group";
-const QString FootprintGroup = "Footprint group";
-const QString AxesGroup = "Axes group";
-const QString VarianceFunctionGroup = "Variance group";
-
-// --- Units&Constants----------------------------------------------------------
-
-const QString UnitsNbins = "nbins";
-const QString UnitsRadians = "Radians";
-const QString UnitsDegrees = "Degrees";
-const QString UnitsMm = "mm";
-const QString UnitsQyQz = "q-space";
-
-const QString STATUS_IDLE = "Idle";
-const QString STATUS_RUNNING = "Running";
-const QString STATUS_FITTING = "Fitting";
-const QString STATUS_COMPLETED = "Completed";
-const QString STATUS_CANCELED = "Canceled";
-const QString STATUS_FAILED = "Failed";
-
-const QString GRADIENT_GRAYSCALE = "Grayscale";
-const QString GRADIENT_HOT = "Hot";
-const QString GRADIENT_COLD = "Cold";
-const QString GRADIENT_NIGHT = "Night";
-const QString GRADIENT_CANDY = "Candy";
-const QString GRADIENT_GEOGRAPHY = "Geography";
-const QString GRADIENT_ION = "Ion";
-const QString GRADIENT_THERMAL = "Thermal";
-const QString GRADIENT_POLAR = "Polar";
-const QString GRADIENT_SPECTRUM = "Spectrum";
-const QString GRADIENT_JET = "Jet";
-const QString GRADIENT_HUES = "Hues";
-
-const QString JOB_RUN_IMMEDIATELY = "Immediately";
-const QString JOB_RUN_IN_BACKGROUND = "In background";
-const QString JOB_BACKUP = "_backup";
-
-const QString SIMULATION_ANALYTICAL = "Analytical";
-const QString SIMULATION_MONTECARLO = "Monte-Carlo Integration";
-
-const QString ALIGNMENT_GENERIC = "Generic";
-const QString ALIGNMENT_TO_SAMPLE = "Perpendicular to sample x-axis";
-const QString ALIGNMENT_TO_DIRECT_BEAM = "Perpendicular to direct beam";
-const QString ALIGNMENT_TO_REFLECTED_BEAM = "Perpendicular to reflected beam";
-const QString ALIGNMENT_TO_REFLECTED_BEAM_DPOS = "Perpendicular to reflected beam (dpos)";
-
-const QString FITPAR_FIXED = "fixed";
-const QString FITPAR_LIMITED = "limited";
-const QString FITPAR_LOWERLIMITED = "lower limited";
-const QString FITPAR_UPPERLIMITED = "upper limited";
-const QString FITPAR_FREE = "free";
-
-const QString DistributionSigmaFactor = "Sigma factor";
-
-const QString LAYOUT_DA = "Decoupling Approximation";
-const QString LAYOUT_SSCA = "Size Space Coupling Approximation";
-
-const QString AMBIENT_LAYER_MATERIAL = "Ambient Layer Material";
-const QString AVERAGE_LAYER_MATERIAL = "Average Layer Material";
-
-// --- Presentation types ----------------------------------------------------------
-
-const QString IntensityDataPresentation = "Color Map";
-const QString SpecularDataPresentation = "Reflectometry";
-const QString IntensityProjectionsPresentation = "Projections";
-const QString FitComparisonPresentation2D = "Fit 2D Data";
-const QString FitComparisonPresentation1D = "Fit 1D Data";
-const QString MaskEditorPresentation = "Mask Editor";
-
-// --- Custom variants ----------------------------------------------------------
-
-const QString ExternalPropertyType = "ExternalProperty";
-const QString ComboPropertyType = "ComboProperty";
-
-// --- Custom editors for variant properties ---
-const QString DefaultEditorType = "Default";
-const QString ScientificEditorType = "SceintificDouble";
-const QString ScientificSpinBoxType = "ScientificSpinBox";
-const QString MaterialEditorExternalType = "ExtMaterialEditor";
-const QString ColorEditorExternalType = "ExtColorEditor";
-const QString MultiSelectionComboEditorType = "MultiSelectionComboEditor";
-
-} // namespace Constants
-
-#endif // BORNAGAIN_GUI_COREGUI_MODELS_ITEM_CONSTANTS_H
diff --git a/GUI/coregui/Views/FitWidgets/FitComparisonController.cpp b/GUI/coregui/Views/FitWidgets/FitComparisonController.cpp
index f4765052effdbdcd6a14f9bc8a65cffedc9e371f..8b266d0cf5d6a47c95c42dd495425f33039a89ef 100644
--- a/GUI/coregui/Views/FitWidgets/FitComparisonController.cpp
+++ b/GUI/coregui/Views/FitWidgets/FitComparisonController.cpp
@@ -51,7 +51,7 @@ using DiffItemController = FitComparisonController2D::DiffItemController;
FitComparisonController2D::FitComparisonController2D(QObject* parent)
: QObject(parent),
- m_diff_item_controller(new DiffItemController(Constants::IntensityDataType, this)),
+ m_diff_item_controller(new DiffItemController("IntensityData", this)),
m_appearanceRepeater(new PropertyRepeater(this)), m_xAxisRepeater(new PropertyRepeater(this)),
m_yAxisRepeater(new PropertyRepeater(this)), m_zAxisRepeater(new PropertyRepeater(this))
{
diff --git a/GUI/coregui/Views/FitWidgets/FitComparisonViewController.cpp b/GUI/coregui/Views/FitWidgets/FitComparisonViewController.cpp
index 4e7237e9c2e4153c738fffd85731ea3d19f067d0..d4573cd81a92d4a206df14d91ffe2175e59daf9b 100644
--- a/GUI/coregui/Views/FitWidgets/FitComparisonViewController.cpp
+++ b/GUI/coregui/Views/FitWidgets/FitComparisonViewController.cpp
@@ -31,7 +31,7 @@ const double relative_diff_max_1d = 4.0;
FitComparison1DViewController::FitComparison1DViewController(QObject* parent)
: QObject(parent),
- m_diff_item_controller(new DiffItemController(Constants::SpecularDataType, this)),
+ m_diff_item_controller(new DiffItemController("SpecularData", this)),
m_diff_view_item(nullptr), m_appearanceRepeater(new PropertyRepeater(this)),
m_xAxisRepeater(new PropertyRepeater(this))
{
@@ -90,8 +90,8 @@ void FitComparison1DViewController::clear()
void FitComparison1DViewController::createDiffViewItem(JobItem* job_item)
{
m_diff_view_item = dynamic_cast<Data1DViewItem*>(
- m_diff_item_controller->model()->insertNewItem(Constants::Data1DViewItemType));
- auto container = m_diff_view_item->model()->insertNewItem(Constants::DataPropertyContainerType,
+ m_diff_item_controller->model()->insertNewItem("Data1DViewItem"));
+ auto container = m_diff_view_item->model()->insertNewItem("DataPropertyContainer",
m_diff_view_item->index(), -1,
Data1DViewItem::T_DATA_PROPERTIES);
dynamic_cast<DataPropertyContainer*>(container)->addItem(m_diff_item_controller->diffItem());
diff --git a/GUI/coregui/Views/FitWidgets/FitParameterWidget.cpp b/GUI/coregui/Views/FitWidgets/FitParameterWidget.cpp
index cd99b3ad9b422efbce34dec4bf2c3f241ce476f2..56b204fb4da92d8f2a202f4d5e375907fcd350f1 100644
--- a/GUI/coregui/Views/FitWidgets/FitParameterWidget.cpp
+++ b/GUI/coregui/Views/FitWidgets/FitParameterWidget.cpp
@@ -129,7 +129,7 @@ void FitParameterWidget::onFitParametersSelectionChanged(const QItemSelection& s
for (auto index : selection.indexes()) {
m_tuningWidget->selectionModel()->clearSelection();
SessionItem* item = m_fitParameterModel->itemForIndex(index);
- if (item->parent()->modelType() == Constants::FitParameterLinkType) {
+ if (item->parent()->modelType() == "FitParameterLink") {
QString link = item->parent()->getItemValue(FitParameterLinkItem::P_LINK).toString();
m_tuningWidget->makeSelected(
FitParameterHelper::getParameterItem(jobItem()->fitParameterContainerItem(), link));
@@ -233,7 +233,7 @@ void FitParameterWidget::init_actions()
void FitParameterWidget::initTuningWidgetContextMenu(QMenu& menu)
{
- if (jobItem()->getStatus() == Constants::STATUS_FITTING) {
+ if (jobItem()->getStatus() == "Fitting") {
setActionsEnabled(false);
return;
}
@@ -267,7 +267,7 @@ void FitParameterWidget::initTuningWidgetContextMenu(QMenu& menu)
void FitParameterWidget::initFitParameterTreeContextMenu(QMenu& menu)
{
- if (jobItem()->getStatus() == Constants::STATUS_FITTING) {
+ if (jobItem()->getStatus() == "Fitting") {
setActionsEnabled(false);
return;
}
@@ -337,7 +337,7 @@ QVector<FitParameterItem*> FitParameterWidget::selectedFitParameters()
QModelIndexList indexes = m_treeView->selectionModel()->selectedIndexes();
for (auto index : indexes) {
if (SessionItem* item = m_fitParameterModel->itemForIndex(index)) {
- if (item->modelType() == Constants::FitParameterType) {
+ if (item->modelType() == "FitParameter") {
FitParameterItem* fitParItem = dynamic_cast<FitParameterItem*>(item);
Q_ASSERT(fitParItem);
result.push_back(fitParItem);
@@ -367,7 +367,7 @@ QVector<FitParameterLinkItem*> FitParameterWidget::selectedFitParameterLinks()
QModelIndexList indexes = m_treeView->selectionModel()->selectedIndexes();
for (QModelIndex index : indexes) {
if (SessionItem* item = m_fitParameterModel->itemForIndex(index)) {
- if (item->parent()->modelType() == Constants::FitParameterLinkType) {
+ if (item->parent()->modelType() == "FitParameterLink") {
FitParameterLinkItem* fitParItem =
dynamic_cast<FitParameterLinkItem*>(item->parent());
Q_ASSERT(fitParItem);
diff --git a/GUI/coregui/Views/FitWidgets/FitSessionController.cpp b/GUI/coregui/Views/FitWidgets/FitSessionController.cpp
index 4699e843776bb42fbcaf7cd5567c9166adb12f2a..45561b67b0905489bedf87aaed6312b4891e980c 100644
--- a/GUI/coregui/Views/FitWidgets/FitSessionController.cpp
+++ b/GUI/coregui/Views/FitWidgets/FitSessionController.cpp
@@ -83,7 +83,7 @@ void FitSessionController::onStartFittingRequest()
m_runFitManager->runFitting(m_objectiveBuilder);
} catch (std::exception& e) {
- m_jobItem->setStatus(Constants::STATUS_FAILED);
+ m_jobItem->setStatus("Failed");
m_fitlog->append(e.what(), FitLogFlags::ERROR);
emit fittingError(QString::fromStdString(e.what()));
}
@@ -121,7 +121,7 @@ void FitSessionController::onFittingStarted()
{
m_fitlog->clearLog();
- m_jobItem->setStatus(Constants::STATUS_FITTING);
+ m_jobItem->setStatus("Fitting");
m_jobItem->setProgress(0);
m_jobItem->setBeginTime(GUIHelpers::currentDateTime());
m_jobItem->setEndTime(QString());
@@ -132,8 +132,8 @@ void FitSessionController::onFittingStarted()
void FitSessionController::onFittingFinished()
{
- if (m_jobItem->getStatus() != Constants::STATUS_FAILED)
- m_jobItem->setStatus(Constants::STATUS_COMPLETED);
+ if (m_jobItem->getStatus() != "Failed")
+ m_jobItem->setStatus("Completed");
m_jobItem->setEndTime(GUIHelpers::currentDateTime());
m_jobItem->setProgress(100);
m_jobItem->setDuration(m_runFitManager->getDuration());
diff --git a/GUI/coregui/Views/FitWidgets/RunFitControlWidget.cpp b/GUI/coregui/Views/FitWidgets/RunFitControlWidget.cpp
index 291345886b687f7ef03363f79ab44e8b56a70e43..f0441cd4f627514fa99a8d6a11b7998cb548bb25 100644
--- a/GUI/coregui/Views/FitWidgets/RunFitControlWidget.cpp
+++ b/GUI/coregui/Views/FitWidgets/RunFitControlWidget.cpp
@@ -156,7 +156,7 @@ void RunFitControlWidget::updateControlElements()
{
setEnabled(isValidJobItem());
- if (jobItem()->getStatus() == Constants::STATUS_FITTING) {
+ if (jobItem()->getStatus() == "Fitting") {
m_startButton->setEnabled(false);
m_stopButton->setEnabled(true);
m_warningSign->clear();
diff --git a/GUI/coregui/Views/ImportDataWidgets/RealDataMaskWidget.cpp b/GUI/coregui/Views/ImportDataWidgets/RealDataMaskWidget.cpp
index 249f969444d383be598974244b5e9b2b579e1ad2..1cf480a22981fe65fb7f5377a414ef3e2b01c477 100644
--- a/GUI/coregui/Views/ImportDataWidgets/RealDataMaskWidget.cpp
+++ b/GUI/coregui/Views/ImportDataWidgets/RealDataMaskWidget.cpp
@@ -69,7 +69,7 @@ MaskContainerItem* RealDataMaskWidget::maskContainer(IntensityDataItem* intensit
{
auto containerItem = intensityData->getItem(IntensityDataItem::T_MASKS);
if (!containerItem)
- containerItem = intensityData->model()->insertNewItem(Constants::MaskContainerType,
+ containerItem = intensityData->model()->insertNewItem("MaskContainer",
intensityData->index());
MaskContainerItem* result = dynamic_cast<MaskContainerItem*>(containerItem);
diff --git a/GUI/coregui/Views/ImportDataWidgets/RealDataPresenter.cpp b/GUI/coregui/Views/ImportDataWidgets/RealDataPresenter.cpp
index 0f6b17423474bff88c5d81a81c4a3c125ca5bd9b..b5ec2f2cc72f2973b656e2f3480bb7cfaf11369d 100644
--- a/GUI/coregui/Views/ImportDataWidgets/RealDataPresenter.cpp
+++ b/GUI/coregui/Views/ImportDataWidgets/RealDataPresenter.cpp
@@ -14,7 +14,6 @@
#include "GUI/coregui/Views/ImportDataWidgets/RealDataPresenter.h"
#include "GUI/coregui/Models/RealDataItem.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/ImportDataWidgets/RealDataMaskWidget.h"
#include "GUI/coregui/Views/IntensityDataWidgets/IntensityDataProjectionsWidget.h"
#include "GUI/coregui/Views/IntensityDataWidgets/IntensityDataWidget.h"
@@ -25,11 +24,11 @@
RealDataPresenter::RealDataPresenter(QWidget* parent) : ItemComboWidget(parent)
{
- registerWidget(Constants::IntensityDataPresentation, create_new<IntensityDataWidget>);
- registerWidget(Constants::IntensityProjectionsPresentation,
+ registerWidget("Color Map", create_new<IntensityDataWidget>);
+ registerWidget("Projections",
create_new<IntensityDataProjectionsWidget>);
- registerWidget(Constants::MaskEditorPresentation, create_new<RealDataMaskWidget>);
- registerWidget(Constants::SpecularDataPresentation, create_new<SpecularDataWidget>);
+ registerWidget("Mask Editor", create_new<RealDataMaskWidget>);
+ registerWidget("Reflectometry", create_new<SpecularDataWidget>);
}
QList<QAction*> RealDataPresenter::actionList()
@@ -43,11 +42,11 @@ QStringList RealDataPresenter::activePresentationList(SessionItem* item)
const auto& underlying_data_model = dynamic_cast<RealDataItem*>(item)->underlyingDataModel();
QStringList result;
- if (underlying_data_model == Constants::IntensityDataType)
- result << Constants::IntensityDataPresentation
- << Constants::IntensityProjectionsPresentation << Constants::MaskEditorPresentation;
- else if (underlying_data_model == Constants::SpecularDataType)
- result << Constants::SpecularDataPresentation;
+ if (underlying_data_model == "IntensityData")
+ result << "Color Map"
+ << "Projections" << "Mask Editor";
+ else if (underlying_data_model == "SpecularData")
+ result << "Reflectometry";
else
throw GUIHelpers::Error(
"Error in RealDataPresenter::activePresentationList: unsupported data type");
diff --git a/GUI/coregui/Views/ImportDataWidgets/RealDataSelectorActions.cpp b/GUI/coregui/Views/ImportDataWidgets/RealDataSelectorActions.cpp
index d7b667e1028b3b7ce9e5c3bf3207cb978bb2570d..edb4c5bbf9cc18c8adbf963227c560d0e76387e9 100644
--- a/GUI/coregui/Views/ImportDataWidgets/RealDataSelectorActions.cpp
+++ b/GUI/coregui/Views/ImportDataWidgets/RealDataSelectorActions.cpp
@@ -151,7 +151,7 @@ void RealDataSelectorActions::importDataLoop(int ndim)
std::unique_ptr<OutputData<double>> data = ImportDataUtils::Import2dData(fileName);
if (data) {
RealDataItem* realDataItem = dynamic_cast<RealDataItem*>(
- m_realDataModel->insertNewItem(Constants::RealDataType));
+ m_realDataModel->insertNewItem("RealData"));
realDataItem->setItemName(baseNameOfLoadedFile);
realDataItem->setOutputData(data.release());
m_selectionModel->clearSelection();
@@ -161,7 +161,7 @@ void RealDataSelectorActions::importDataLoop(int ndim)
auto data = ImportDataUtils::Import1dData(fileName);
if (data) {
RealDataItem* realDataItem = dynamic_cast<RealDataItem*>(
- m_realDataModel->insertNewItem(Constants::RealDataType));
+ m_realDataModel->insertNewItem("RealData"));
realDataItem->setItemName(baseNameOfLoadedFile);
realDataItem->setImportData(std::move(data));
m_selectionModel->clearSelection();
diff --git a/GUI/coregui/Views/InfoWidgets/DistributionWidget.cpp b/GUI/coregui/Views/InfoWidgets/DistributionWidget.cpp
index c2e85926320d4ff5f5e0f2be8d9408e6e5f5e377..28e095323cb1684f96f0e73a39d98e5f257d2244 100644
--- a/GUI/coregui/Views/InfoWidgets/DistributionWidget.cpp
+++ b/GUI/coregui/Views/InfoWidgets/DistributionWidget.cpp
@@ -163,7 +163,7 @@ void DistributionWidget::init_plot()
void DistributionWidget::plot_distributions()
{
- if (m_item->modelType() == Constants::DistributionNoneType)
+ if (m_item->modelType() == "DistributionNone")
plot_single_value();
else
@@ -174,7 +174,7 @@ void DistributionWidget::plot_distributions()
void DistributionWidget::plot_single_value()
{
- Q_ASSERT(m_item->displayName() == Constants::DistributionNoneType);
+ Q_ASSERT(m_item->displayName() == "DistributionNone");
double value = m_item->getItemValue(DistributionNoneItem::P_MEAN).toDouble();
@@ -187,7 +187,7 @@ void DistributionWidget::plot_single_value()
void DistributionWidget::plot_multiple_values()
{
- Q_ASSERT(m_item->displayName() != Constants::DistributionNoneType);
+ Q_ASSERT(m_item->displayName() != "DistributionNone");
int numberOfSamples = m_item->getItemValue(DistributionItem::P_NUMBER_OF_SAMPLES).toInt();
double sigmafactor(0.0);
diff --git a/GUI/coregui/Views/InstrumentWidgets/DetectorMaskDelegate.cpp b/GUI/coregui/Views/InstrumentWidgets/DetectorMaskDelegate.cpp
index da3d669c7071b0c7905404fb846ea0905625b97a..a3ef61e847aff3c4b51ada81b50586208a648a62 100644
--- a/GUI/coregui/Views/InstrumentWidgets/DetectorMaskDelegate.cpp
+++ b/GUI/coregui/Views/InstrumentWidgets/DetectorMaskDelegate.cpp
@@ -56,7 +56,7 @@ void DetectorMaskDelegate::createIntensityDataItem()
m_tempIntensityDataModel->clear();
m_intensityItem = dynamic_cast<IntensityDataItem*>(
- m_tempIntensityDataModel->insertNewItem(Constants::IntensityDataType));
+ m_tempIntensityDataModel->insertNewItem("IntensityData"));
Q_ASSERT(m_intensityItem);
m_intensityItem->getItem(IntensityDataItem::P_PROJECTIONS_FLAG)->setEnabled(false);
@@ -71,7 +71,7 @@ void DetectorMaskDelegate::createIntensityDataItem()
// creating output data corresponding to the detector
auto instrument = dynamic_cast<const GISASInstrumentItem*>(
- ModelPath::ancestor(m_detectorItem, Constants::GISASInstrumentType));
+ ModelPath::ancestor(m_detectorItem, "GISASInstrument"));
JobItemUtils::createDefaultDetectorMap(m_intensityItem, instrument);
m_intensityItem->getOutputData()->setAllTo(1.0);
diff --git a/GUI/coregui/Views/InstrumentWidgets/DetectorPresenter.cpp b/GUI/coregui/Views/InstrumentWidgets/DetectorPresenter.cpp
index fd9df849e4b41aa6c3bb5bd4da6d0ecee0b00662..4a010cda519ef67d398aea80cedc6214fed750d6 100644
--- a/GUI/coregui/Views/InstrumentWidgets/DetectorPresenter.cpp
+++ b/GUI/coregui/Views/InstrumentWidgets/DetectorPresenter.cpp
@@ -36,9 +36,9 @@ QString DetectorPresenter::itemPresentation() const
if (!currentItem())
return {};
- if (currentItem()->modelType() == Constants::SphericalDetectorType)
+ if (currentItem()->modelType() == "SphericalDetector")
return SphericalDetectorPresentation;
- else if (currentItem()->modelType() == Constants::RectangularDetectorType)
+ else if (currentItem()->modelType() == "RectangularDetector")
return RectangularDetectorPresentation;
else
throw GUIHelpers::Error("DetectorPresenter::itemPresentation() -> Error. Wrong item "
diff --git a/GUI/coregui/Views/InstrumentWidgets/InstrumentPresenter.cpp b/GUI/coregui/Views/InstrumentWidgets/InstrumentPresenter.cpp
index 09c06e3e6828826a384e43977e2c1cafdac995ba..8ffa4d3b82564df453537abc86fbbdc8b7feb0b2 100644
--- a/GUI/coregui/Views/InstrumentWidgets/InstrumentPresenter.cpp
+++ b/GUI/coregui/Views/InstrumentWidgets/InstrumentPresenter.cpp
@@ -14,7 +14,6 @@
#include "GUI/coregui/Views/InstrumentWidgets/InstrumentPresenter.h"
#include "GUI/coregui/Models/SessionItem.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/InstrumentWidgets/DepthProbeInstrumentEditor.h"
#include "GUI/coregui/Views/InstrumentWidgets/GISASInstrumentEditor.h"
#include "GUI/coregui/Views/InstrumentWidgets/OffSpecInstrumentEditor.h"
@@ -43,13 +42,13 @@ QString InstrumentPresenter::itemPresentation() const
if (!currentItem())
return {};
- if (currentItem()->modelType() == Constants::GISASInstrumentType)
+ if (currentItem()->modelType() == "GISASInstrument")
return GISASPresentation;
- else if (currentItem()->modelType() == Constants::OffSpecInstrumentType)
+ else if (currentItem()->modelType() == "OffSpecInstrument")
return OffSpecPresentation;
- else if (currentItem()->modelType() == Constants::SpecularInstrumentType)
+ else if (currentItem()->modelType() == "SpecularInstrument")
return SpecularPresentation;
- else if (currentItem()->modelType() == Constants::DepthProbeInstrumentType)
+ else if (currentItem()->modelType() == "DepthProbeInstrument")
return DepthProbePresentation;
else
throw GUIHelpers::Error("InstrumentPresenter::itemPresentation() -> Error. Wrong item "
diff --git a/GUI/coregui/Views/InstrumentWidgets/InstrumentViewActions.cpp b/GUI/coregui/Views/InstrumentWidgets/InstrumentViewActions.cpp
index 0d30f430c59365585f66fb163670e4a5a81553b6..1f87673da895d7da512048f9c461624bea83a48d 100644
--- a/GUI/coregui/Views/InstrumentWidgets/InstrumentViewActions.cpp
+++ b/GUI/coregui/Views/InstrumentWidgets/InstrumentViewActions.cpp
@@ -74,16 +74,16 @@ void InstrumentViewActions::onAddInstrument()
QString instrumentType = action->data().toString();
- if (instrumentType == Constants::GISASInstrumentType) {
+ if (instrumentType == "GISASInstrument") {
auto instrument = m_model->insertNewItem(instrumentType);
instrument->setItemName(suggestInstrumentName("GISAS"));
- } else if (instrumentType == Constants::OffSpecInstrumentType) {
+ } else if (instrumentType == "OffSpecInstrument") {
auto instrument = m_model->insertNewItem(instrumentType);
instrument->setItemName(suggestInstrumentName("OffSpec"));
- } else if (instrumentType == Constants::SpecularInstrumentType) {
+ } else if (instrumentType == "SpecularInstrument") {
auto instrument = m_model->insertNewItem(instrumentType);
instrument->setItemName(suggestInstrumentName("Specular"));
- } else if (instrumentType == Constants::DepthProbeInstrumentType) {
+ } else if (instrumentType == "DepthProbeInstrument") {
auto instrument = m_model->insertNewItem(instrumentType);
instrument->setItemName(suggestInstrumentName("DepthProbe"));
} else {
@@ -132,7 +132,7 @@ void InstrumentViewActions::onCloneInstrument()
auto axis_group = instrument->beamItem()->inclinationAxisGroup();
auto donor_axis = dynamic_cast<PointwiseAxisItem*>(
- axis_group->getItemOfType(Constants::PointwiseAxisType));
+ axis_group->getItemOfType("PointwiseAxis"));
if (!donor_axis->containsNonXMLData())
return;
@@ -140,7 +140,7 @@ void InstrumentViewActions::onCloneInstrument()
dynamic_cast<PointwiseAxisItem*>(dynamic_cast<SpecularInstrumentItem*>(clone)
->beamItem()
->inclinationAxisGroup()
- ->getItemOfType(Constants::PointwiseAxisType));
+ ->getItemOfType("PointwiseAxis"));
acceptor_axis->init(*donor_axis->getAxis(), donor_axis->getUnitsLabel());
}
}
@@ -216,23 +216,23 @@ void InstrumentViewActions::initAddInstrumentMenu()
m_addInstrumentMenu->setToolTipsVisible(true);
auto action = m_addInstrumentMenu->addAction("GISAS");
- action->setData(QVariant::fromValue(Constants::GISASInstrumentType));
+ action->setData(QVariant::fromValue(QString{"GISASInstrument"}));
action->setToolTip("Add GISAS instrument with default settings");
connect(action, &QAction::triggered, this, &InstrumentViewActions::onAddInstrument);
m_addInstrumentMenu->setDefaultAction(action);
action = m_addInstrumentMenu->addAction("OffSpec");
- action->setData(QVariant::fromValue(Constants::OffSpecInstrumentType));
+ action->setData(QVariant::fromValue(QString{"OffSpecInstrument"}));
action->setToolTip("Add OffSpec instrument with default settings");
connect(action, &QAction::triggered, this, &InstrumentViewActions::onAddInstrument);
action = m_addInstrumentMenu->addAction("Specular");
- action->setData(QVariant::fromValue(Constants::SpecularInstrumentType));
+ action->setData(QVariant::fromValue(QString{"SpecularInstrument"}));
action->setToolTip("Add Specular instrument with default settings");
connect(action, &QAction::triggered, this, &InstrumentViewActions::onAddInstrument);
action = m_addInstrumentMenu->addAction("DepthProbe");
- action->setData(QVariant::fromValue(Constants::DepthProbeInstrumentType));
+ action->setData(QVariant::fromValue(QString{"DepthProbeInstrument"}));
action->setToolTip("Add DepthProbe instrument with default settings");
connect(action, &QAction::triggered, this, &InstrumentViewActions::onAddInstrument);
}
diff --git a/GUI/coregui/Views/InstrumentWidgets/RectangularDetectorEditor.cpp b/GUI/coregui/Views/InstrumentWidgets/RectangularDetectorEditor.cpp
index b7f7dd34c887d397a93fb37099a67094f171c6e6..e977b06fe8d06592598a1abe14c473214a5d3818 100644
--- a/GUI/coregui/Views/InstrumentWidgets/RectangularDetectorEditor.cpp
+++ b/GUI/coregui/Views/InstrumentWidgets/RectangularDetectorEditor.cpp
@@ -126,7 +126,7 @@ void RectangularDetectorEditor::init_alignment_editors()
ComboProperty alignment =
detectorItem()->getItemValue(RectangularDetectorItem::P_ALIGNMENT).value<ComboProperty>();
- if (alignment.getValue() == Constants::ALIGNMENT_GENERIC) {
+ if (alignment.getValue() == "Generic") {
m_positionsEditor->show();
m_normalEditor->show();
m_directionEditor->show();
@@ -140,15 +140,15 @@ void RectangularDetectorEditor::init_alignment_editors()
auto directionVectorItem = detectorItem()->getItem(RectangularDetectorItem::P_DIRECTION);
m_directionEditor->setItem(directionVectorItem);
- } else if (alignment.getValue() == Constants::ALIGNMENT_TO_DIRECT_BEAM
- || alignment.getValue() == Constants::ALIGNMENT_TO_REFLECTED_BEAM_DPOS) {
+ } else if (alignment.getValue() == "Perpendicular to direct beam"
+ || alignment.getValue() == "Perpendicular to reflected beam (dpos)") {
m_positionsEditor->show();
m_positionsEditor->addItem(detectorItem()->getItem(RectangularDetectorItem::P_DBEAM_U0));
m_positionsEditor->addItem(detectorItem()->getItem(RectangularDetectorItem::P_DBEAM_V0));
m_positionsEditor->addItem(detectorItem()->getItem(RectangularDetectorItem::P_DISTANCE));
- } else if (alignment.getValue() == Constants::ALIGNMENT_TO_SAMPLE
- || alignment.getValue() == Constants::ALIGNMENT_TO_REFLECTED_BEAM) {
+ } else if (alignment.getValue() == "Perpendicular to sample x-axis"
+ || alignment.getValue() == "Perpendicular to reflected beam") {
m_positionsEditor->show();
m_positionsEditor->addItem(detectorItem()->getItem(RectangularDetectorItem::P_U0));
diff --git a/GUI/coregui/Views/IntensityDataWidgets/ColorMap.cpp b/GUI/coregui/Views/IntensityDataWidgets/ColorMap.cpp
index 3f63f0c83f1c434e7baade845fc977c107dc26b7..44a9f15dff286c81833d42887f799d7d9195b268 100644
--- a/GUI/coregui/Views/IntensityDataWidgets/ColorMap.cpp
+++ b/GUI/coregui/Views/IntensityDataWidgets/ColorMap.cpp
@@ -213,8 +213,8 @@ void ColorMap::subscribeToItem()
intensityItem()->mapper()->setOnChildPropertyChange(
[this](SessionItem* item, const QString name) {
- if (item->modelType() == Constants::BasicAxisType
- || item->modelType() == Constants::AmplitudeAxisType)
+ if (item->modelType() == "BasicAxis"
+ || item->modelType() == "AmplitudeAxis")
onAxisPropertyChanged(item->itemName(), name);
},
this);
diff --git a/GUI/coregui/Views/IntensityDataWidgets/ColorMapUtils.cpp b/GUI/coregui/Views/IntensityDataWidgets/ColorMapUtils.cpp
index f485d8a02b6c99c88cad748f591c11c0cb00cf50..c9a08a5937fb4f0c441b9f63b8950d63a1461b57 100644
--- a/GUI/coregui/Views/IntensityDataWidgets/ColorMapUtils.cpp
+++ b/GUI/coregui/Views/IntensityDataWidgets/ColorMapUtils.cpp
@@ -14,7 +14,6 @@
#include "GUI/coregui/Views/IntensityDataWidgets/ColorMapUtils.h"
#include "GUI/coregui/Models/IntensityDataItem.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/IntensityDataWidgets/ColorMap.h"
#include "GUI/coregui/utils/GUIHelpers.h"
#include "GUI/coregui/utils/StyleUtils.h"
@@ -27,18 +26,18 @@ gradient_map_t createGradientMap()
{
gradient_map_t result;
- result[Constants::GRADIENT_GRAYSCALE] = QCPColorGradient::gpGrayscale;
- result[Constants::GRADIENT_HOT] = QCPColorGradient::gpHot;
- result[Constants::GRADIENT_COLD] = QCPColorGradient::gpCold;
- result[Constants::GRADIENT_NIGHT] = QCPColorGradient::gpNight;
- result[Constants::GRADIENT_CANDY] = QCPColorGradient::gpCandy;
- result[Constants::GRADIENT_GEOGRAPHY] = QCPColorGradient::gpGeography;
- result[Constants::GRADIENT_ION] = QCPColorGradient::gpIon;
- result[Constants::GRADIENT_THERMAL] = QCPColorGradient::gpThermal;
- result[Constants::GRADIENT_POLAR] = QCPColorGradient::gpPolar;
- result[Constants::GRADIENT_SPECTRUM] = QCPColorGradient::gpSpectrum;
- result[Constants::GRADIENT_JET] = QCPColorGradient::gpJet;
- result[Constants::GRADIENT_HUES] = QCPColorGradient::gpHues;
+ result["Grayscale"] = QCPColorGradient::gpGrayscale;
+ result["Hot"] = QCPColorGradient::gpHot;
+ result["Cold"] = QCPColorGradient::gpCold;
+ result["Night"] = QCPColorGradient::gpNight;
+ result["Candy"] = QCPColorGradient::gpCandy;
+ result["Geography"] = QCPColorGradient::gpGeography;
+ result["Ion"] = QCPColorGradient::gpIon;
+ result["Thermal"] = QCPColorGradient::gpThermal;
+ result["Polar"] = QCPColorGradient::gpPolar;
+ result["Spectrum"] = QCPColorGradient::gpSpectrum;
+ result["Jet"] = QCPColorGradient::gpJet;
+ result["Hues"] = QCPColorGradient::gpHues;
return result;
}
diff --git a/GUI/coregui/Views/IntensityDataWidgets/IntensityDataFFTPresenter.cpp b/GUI/coregui/Views/IntensityDataWidgets/IntensityDataFFTPresenter.cpp
index 4669d006213738b3f3e4f754e18e8a8e01a9c713..c96a3a1163d1433ea349ad07f146fae464668a17 100644
--- a/GUI/coregui/Views/IntensityDataWidgets/IntensityDataFFTPresenter.cpp
+++ b/GUI/coregui/Views/IntensityDataWidgets/IntensityDataFFTPresenter.cpp
@@ -26,7 +26,7 @@ IntensityDataFFTPresenter::IntensityDataFFTPresenter(QWidget* parent)
m_fftItem(nullptr), m_in_fft_mode(false)
{
m_fftItem =
- dynamic_cast<IntensityDataItem*>(m_fftModel->insertNewItem(Constants::IntensityDataType));
+ dynamic_cast<IntensityDataItem*>(m_fftModel->insertNewItem("IntensityData"));
m_fftAction = new QAction(this);
m_fftAction->setText("Fourier");
diff --git a/GUI/coregui/Views/IntensityDataWidgets/IntensityDataProjectionsWidget.cpp b/GUI/coregui/Views/IntensityDataWidgets/IntensityDataProjectionsWidget.cpp
index 6ac60aa9024277d5657fb3a8c6d11028da177049..d6cac9c50a5c94a38355cea9ee0e0e0f59c139c9 100644
--- a/GUI/coregui/Views/IntensityDataWidgets/IntensityDataProjectionsWidget.cpp
+++ b/GUI/coregui/Views/IntensityDataWidgets/IntensityDataProjectionsWidget.cpp
@@ -62,7 +62,7 @@ IntensityDataProjectionsWidget::projectionContainer(IntensityDataItem* intensity
auto containerItem = intensityItem->getItem(IntensityDataItem::T_PROJECTIONS);
if (!containerItem)
- containerItem = intensityItem->model()->insertNewItem(Constants::ProjectionContainerType,
+ containerItem = intensityItem->model()->insertNewItem("ProjectionContainer",
intensityItem->index(), -1,
IntensityDataItem::T_PROJECTIONS);
diff --git a/GUI/coregui/Views/IntensityDataWidgets/ProjectionsPlot.cpp b/GUI/coregui/Views/IntensityDataWidgets/ProjectionsPlot.cpp
index 79275b1a6c58d9fed204abe8cedab7b1ed89dc15..a434d0374ffcad95122e38781e5ba8e6973f1cf7 100644
--- a/GUI/coregui/Views/IntensityDataWidgets/ProjectionsPlot.cpp
+++ b/GUI/coregui/Views/IntensityDataWidgets/ProjectionsPlot.cpp
@@ -89,8 +89,8 @@ void ProjectionsPlot::subscribeToItem()
// Update to changed IntensityDataItem axes
intensityItem()->mapper()->setOnChildPropertyChange(
[this](SessionItem* item, const QString name) {
- if (item->modelType() == Constants::BasicAxisType
- || item->modelType() == Constants::AmplitudeAxisType)
+ if (item->modelType() == "BasicAxis"
+ || item->modelType() == "AmplitudeAxis")
onAxisPropertyChanged(item->itemName(), name);
},
this);
@@ -273,7 +273,7 @@ void ProjectionsPlot::setGraphFromItem(QCPGraph* graph, SessionItem* item)
{
std::unique_ptr<Histogram1D> hist;
- if (item->modelType() == Constants::HorizontalLineMaskType) {
+ if (item->modelType() == "HorizontalLineMask") {
double value = item->getItemValue(HorizontalLineItem::P_POSY).toDouble();
hist.reset(m_hist2d->projectionX(value));
} else {
@@ -312,5 +312,5 @@ void ProjectionsPlot::replot()
bool ProjectionsPlot::isHorizontalType()
{
- return m_projectionType == Constants::HorizontalLineMaskType;
+ return m_projectionType == "HorizontalLineMask";
}
diff --git a/GUI/coregui/Views/IntensityDataWidgets/SaveProjectionsAssistant.cpp b/GUI/coregui/Views/IntensityDataWidgets/SaveProjectionsAssistant.cpp
index e8c242ca5d1e3f2a4f398d9ac6870ba32d51af4a..6a326612675bb45e556e190ae59b84f57d6e7d41 100644
--- a/GUI/coregui/Views/IntensityDataWidgets/SaveProjectionsAssistant.cpp
+++ b/GUI/coregui/Views/IntensityDataWidgets/SaveProjectionsAssistant.cpp
@@ -19,7 +19,6 @@
#include "GUI/coregui/Models/IntensityDataItem.h"
#include "GUI/coregui/Models/MaskItems.h"
#include "GUI/coregui/Models/ProjectionItems.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/mainwindow/ProjectUtils.h"
#include "GUI/coregui/utils/GUIHelpers.h"
#include <QFileDialog>
@@ -68,11 +67,11 @@ void SaveProjectionsAssistant::saveProjections(QWidget* parent, IntensityDataIte
QTextStream out(&file);
out << "# Projections along x-axis (horizontal projections) \n";
- out << projectionsToString(Constants::HorizontalLineMaskType, intensityItem);
+ out << projectionsToString("HorizontalLineMask", intensityItem);
out << "\n";
out << "# Projections along y-axis (vertical projections) \n";
- out << projectionsToString(Constants::VerticalLineMaskType, intensityItem);
+ out << projectionsToString("VerticalLineMask", intensityItem);
out << "\n";
file.close();
@@ -112,14 +111,14 @@ SaveProjectionsAssistant::projectionsData(const QString& projectionsType,
IntensityDataItem* intensityItem)
{
ProjectionsData result;
- projectionsType == Constants::VerticalLineMaskType ? result.is_horizontal = false
+ projectionsType == "VerticalLineMask" ? result.is_horizontal = false
: result.is_horizontal = true;
for (auto item : projectionItems(projectionsType, intensityItem)) {
std::unique_ptr<Histogram1D> hist;
SaveProjectionsAssistant::Projection data;
- if (item->modelType() == Constants::HorizontalLineMaskType) {
+ if (item->modelType() == "HorizontalLineMask") {
data.axis_value = item->getItemValue(HorizontalLineItem::P_POSY).toDouble();
hist.reset(m_hist2d->projectionX(data.axis_value));
} else {
@@ -152,7 +151,7 @@ QVector<SessionItem*> SaveProjectionsAssistant::projectionItems(const QString& p
auto result = intensityItem->projectionContainerItem()->getChildrenOfType(projectionsType);
std::sort(result.begin(), result.end(), [=](SessionItem* item1, SessionItem* item2) {
QString propertyName = HorizontalLineItem::P_POSY;
- if (projectionsType != Constants::HorizontalLineMaskType)
+ if (projectionsType != "HorizontalLineMask")
propertyName = VerticalLineItem::P_POSX;
return item1->getItemValue(propertyName).toDouble()
diff --git a/GUI/coregui/Views/JobWidgets/JobListViewDelegate.cpp b/GUI/coregui/Views/JobWidgets/JobListViewDelegate.cpp
index 6d0d4e30225a0e7d45a646e4ffc6f84fddc8e88f..5d9334210ceca15a0082e1b3e6930d3857d8c1b5 100644
--- a/GUI/coregui/Views/JobWidgets/JobListViewDelegate.cpp
+++ b/GUI/coregui/Views/JobWidgets/JobListViewDelegate.cpp
@@ -27,11 +27,11 @@
JobListViewDelegate::JobListViewDelegate(QWidget* parent) : QItemDelegate(parent)
{
m_buttonState = QStyle::State_Enabled;
- m_status_to_color[Constants::STATUS_IDLE] = QColor(255, 286, 12);
- m_status_to_color[Constants::STATUS_RUNNING] = QColor(5, 150, 230);
- m_status_to_color[Constants::STATUS_COMPLETED] = QColor(5, 150, 230);
- m_status_to_color[Constants::STATUS_CANCELED] = QColor(186, 0, 0);
- m_status_to_color[Constants::STATUS_FAILED] = QColor(255, 186, 12);
+ m_status_to_color["Idle"] = QColor(255, 286, 12);
+ m_status_to_color["Running"] = QColor(5, 150, 230);
+ m_status_to_color["Completed"] = QColor(5, 150, 230);
+ m_status_to_color["Canceled"] = QColor(186, 0, 0);
+ m_status_to_color["Failed"] = QColor(255, 186, 12);
}
void JobListViewDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option,
diff --git a/GUI/coregui/Views/JobWidgets/JobPropertiesWidget.cpp b/GUI/coregui/Views/JobWidgets/JobPropertiesWidget.cpp
index e17845e4abfaccb590d3435aa7408f35641af906..e928e1aca06d49bcf26e817397e81e7ccaac1340 100644
--- a/GUI/coregui/Views/JobWidgets/JobPropertiesWidget.cpp
+++ b/GUI/coregui/Views/JobWidgets/JobPropertiesWidget.cpp
@@ -91,7 +91,7 @@ void JobPropertiesWidget::updateItem()
return;
if (JobItem* item = jobItem()) {
- if (item->getStatus() == Constants::STATUS_FAILED)
+ if (item->getStatus() == "Failed")
m_tabWidget->tabBar()->setTabTextColor(JOB_COMMENTS, Qt::red);
else
m_tabWidget->tabBar()->setTabTextColor(JOB_COMMENTS, Qt::black);
diff --git a/GUI/coregui/Views/JobWidgets/JobResultsPresenter.cpp b/GUI/coregui/Views/JobWidgets/JobResultsPresenter.cpp
index 25afcc8e0c4e9ecdb6e54466b7ef4b05a8f6b410..8cc4796c8369ac086daf339ed235d804ba1ea2e7 100644
--- a/GUI/coregui/Views/JobWidgets/JobResultsPresenter.cpp
+++ b/GUI/coregui/Views/JobWidgets/JobResultsPresenter.cpp
@@ -27,15 +27,15 @@ namespace
const bool use_job_last_presentation = true;
const std::map<QString, QString> instrument_to_default_presentaion{
- {Constants::SpecularInstrumentType, Constants::SpecularDataPresentation},
- {Constants::GISASInstrumentType, Constants::IntensityDataPresentation},
- {Constants::OffSpecInstrumentType, Constants::IntensityDataPresentation},
- {Constants::DepthProbeInstrumentType, Constants::IntensityDataPresentation}};
+ {"SpecularInstrument", "Reflectometry"},
+ {"GISASInstrument", "Color Map"},
+ {"OffSpecInstrument", "Color Map"},
+ {"DepthProbeInstrument", "Color Map"}};
const std::map<QString, QString> instrument_to_fit_presentaion{
- {Constants::SpecularInstrumentType, Constants::FitComparisonPresentation1D},
- {Constants::GISASInstrumentType, Constants::FitComparisonPresentation2D},
- {Constants::OffSpecInstrumentType, Constants::FitComparisonPresentation2D}};
+ {"SpecularInstrument", "Fit 1D Data"},
+ {"GISASInstrument", "Fit 2D Data"},
+ {"OffSpecInstrument", "Fit 2D Data"}};
const std::map<JobViewFlags::EActivities, std::map<QString, QString>> activity_to_presentation{
{JobViewFlags::FITTING_ACTIVITY, instrument_to_fit_presentaion},
@@ -43,13 +43,13 @@ const std::map<JobViewFlags::EActivities, std::map<QString, QString>> activity_t
{JobViewFlags::JOB_VIEW_ACTIVITY, instrument_to_default_presentaion}};
const std::map<QString, QStringList> default_active_presentation_list{
- {Constants::SpecularInstrumentType, {Constants::SpecularDataPresentation}},
- {{Constants::GISASInstrumentType},
- {Constants::IntensityDataPresentation, Constants::IntensityProjectionsPresentation}},
- {{Constants::OffSpecInstrumentType},
- {Constants::IntensityDataPresentation, Constants::IntensityProjectionsPresentation}},
- {{Constants::DepthProbeInstrumentType},
- {Constants::IntensityDataPresentation, Constants::IntensityProjectionsPresentation}}};
+ {"SpecularInstrument", {"Reflectometry"}},
+ {{"GISASInstrument"},
+ {"Color Map", "Projections"}},
+ {{"OffSpecInstrument"},
+ {"Color Map", "Projections"}},
+ {{"DepthProbeInstrument"},
+ {"Color Map", "Projections"}}};
template <class QStringObj>
QStringObj getPresentations(const SessionItem* job_item,
@@ -65,15 +65,15 @@ QStringObj getPresentations(const SessionItem* job_item,
JobResultsPresenter::JobResultsPresenter(QWidget* parent) : ItemComboWidget(parent)
{
- registerWidget(Constants::IntensityDataPresentation, create_new<IntensityDataWidget>);
+ registerWidget("Color Map", create_new<IntensityDataWidget>);
- registerWidget(Constants::IntensityProjectionsPresentation,
+ registerWidget("Projections",
create_new<IntensityDataProjectionsWidget>);
- registerWidget(Constants::FitComparisonPresentation1D, create_new<FitComparisonWidget1D>);
- registerWidget(Constants::FitComparisonPresentation2D, create_new<FitComparisonWidget>);
+ registerWidget("Fit 1D Data", create_new<FitComparisonWidget1D>);
+ registerWidget("Fit 2D Data", create_new<FitComparisonWidget>);
- registerWidget(Constants::SpecularDataPresentation, create_new<SpecularDataWidget>);
+ registerWidget("Reflectometry", create_new<SpecularDataWidget>);
}
QString JobResultsPresenter::itemPresentation() const
diff --git a/GUI/coregui/Views/JobWidgets/JobSelectorActions.cpp b/GUI/coregui/Views/JobWidgets/JobSelectorActions.cpp
index f7f7930d8c20106f7bfa84db16044c892eb3374f..7271d7601790198d8c95af42b7eaf78a43221bf1 100644
--- a/GUI/coregui/Views/JobWidgets/JobSelectorActions.cpp
+++ b/GUI/coregui/Views/JobWidgets/JobSelectorActions.cpp
@@ -161,7 +161,7 @@ bool JobSelectorActions::canRunJob(const QModelIndex& index) const
const JobItem* jobItem = m_jobModel->getJobItemForIndex(index);
- if (jobItem->isRunning() || jobItem->getStatus() == Constants::STATUS_FITTING)
+ if (jobItem->isRunning() || jobItem->getStatus() == "Fitting")
return false;
return true;
@@ -173,7 +173,7 @@ bool JobSelectorActions::canRemoveJob(const QModelIndex& index) const
return false;
const JobItem* jobItem = m_jobModel->getJobItemForIndex(index);
- if (jobItem->isRunning() || jobItem->getStatus() == Constants::STATUS_FITTING)
+ if (jobItem->isRunning() || jobItem->getStatus() == "Fitting")
return false;
return true;
diff --git a/GUI/coregui/Views/JobWidgets/ParameterTuningWidget.cpp b/GUI/coregui/Views/JobWidgets/ParameterTuningWidget.cpp
index ec596c695209abfd478bada37614345622b7dc7a..b90c215b03674b5ec0f0ad06b31f04fa0adcfa72 100644
--- a/GUI/coregui/Views/JobWidgets/ParameterTuningWidget.cpp
+++ b/GUI/coregui/Views/JobWidgets/ParameterTuningWidget.cpp
@@ -197,7 +197,7 @@ JobItem* ParameterTuningWidget::jobItem()
void ParameterTuningWidget::updateDragAndDropSettings()
{
Q_ASSERT(jobItem());
- if (jobItem()->getStatus() == Constants::STATUS_FITTING) {
+ if (jobItem()->getStatus() == "Fitting") {
setTuningDelegateEnabled(false);
m_treeView->setDragDropMode(QAbstractItemView::NoDragDrop);
} else {
diff --git a/GUI/coregui/Views/JobWidgets/ProjectionsEditorCanvas.cpp b/GUI/coregui/Views/JobWidgets/ProjectionsEditorCanvas.cpp
index ddd77641b580cba46cda61e227831a7f0baa9ae6..0de65d54ad0eabdd789b0afae570a368200b313e 100644
--- a/GUI/coregui/Views/JobWidgets/ProjectionsEditorCanvas.cpp
+++ b/GUI/coregui/Views/JobWidgets/ProjectionsEditorCanvas.cpp
@@ -84,10 +84,10 @@ void ProjectionsEditorCanvas::onEnteringColorMap()
if (m_currentActivity == MaskEditorFlags::HORIZONTAL_LINE_MODE)
m_liveProjection =
- m_model->insertNewItem(Constants::HorizontalLineMaskType, m_containerIndex);
+ m_model->insertNewItem("HorizontalLineMask", m_containerIndex);
else if (m_currentActivity == MaskEditorFlags::VERTICAL_LINE_MODE)
m_liveProjection =
- m_model->insertNewItem(Constants::VerticalLineMaskType, m_containerIndex);
+ m_model->insertNewItem("VerticalLineMask", m_containerIndex);
if (m_liveProjection)
m_liveProjection->setItemValue(MaskItem::P_IS_VISIBLE, false);
diff --git a/GUI/coregui/Views/JobWidgets/ProjectionsWidget.cpp b/GUI/coregui/Views/JobWidgets/ProjectionsWidget.cpp
index 42752b54535a492ef9a7951546de245c9a155e0e..43bc2829c954f6c714b273d53579b9d4adfe1793 100644
--- a/GUI/coregui/Views/JobWidgets/ProjectionsWidget.cpp
+++ b/GUI/coregui/Views/JobWidgets/ProjectionsWidget.cpp
@@ -13,7 +13,6 @@
// ************************************************************************** //
#include "GUI/coregui/Views/JobWidgets/ProjectionsWidget.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/IntensityDataWidgets/ProjectionsPlot.h"
#include <QTabWidget>
#include <QVBoxLayout>
@@ -26,8 +25,8 @@ const int vertical_projection_tab = 1;
ProjectionsWidget::ProjectionsWidget(QWidget* parent)
: SessionItemWidget(parent),
- m_xProjection(new ProjectionsPlot(Constants::HorizontalLineMaskType)),
- m_yProjection(new ProjectionsPlot(Constants::VerticalLineMaskType)),
+ m_xProjection(new ProjectionsPlot("HorizontalLineMask")),
+ m_yProjection(new ProjectionsPlot("VerticalLineMask")),
m_tabWidget(new QTabWidget)
{
QVBoxLayout* layout = new QVBoxLayout;
diff --git a/GUI/coregui/Views/MaskWidgets/MaskDrawingContext.cpp b/GUI/coregui/Views/MaskWidgets/MaskDrawingContext.cpp
index 85a2a1e439f6a341155eb7a5c0aec23b2174ad2c..57fe23a11cf5fed0bed62b284c957a97c82337af 100644
--- a/GUI/coregui/Views/MaskWidgets/MaskDrawingContext.cpp
+++ b/GUI/coregui/Views/MaskWidgets/MaskDrawingContext.cpp
@@ -13,7 +13,6 @@
// ************************************************************************** //
#include "GUI/coregui/Views/MaskWidgets/MaskDrawingContext.h"
-#include "GUI/coregui/Models/item_constants.h"
MaskDrawingContext::MaskDrawingContext()
: m_current_activity(MaskEditorFlags::PAN_ZOOM_MODE), m_mask_value(MaskEditorFlags::MASK_ON),
@@ -124,11 +123,11 @@ bool MaskDrawingContext::isActivityRequiresDrawingCancel(
QString MaskDrawingContext::activityToModelType() const
{
if (isRectangleMode())
- return Constants::RectangleMaskType;
+ return "RectangleMask";
if (isEllipseMode())
- return Constants::EllipseMaskType;
+ return "EllipseMask";
if (isROIMode())
- return Constants::RegionOfInterestType;
+ return "RegionOfInterest";
return QString();
}
diff --git a/GUI/coregui/Views/MaskWidgets/MaskEditor.cpp b/GUI/coregui/Views/MaskWidgets/MaskEditor.cpp
index c6193b9fc56f4aae1bde107ffda51686bee0a919..0da7c22262e59fc7eb0f7b884bb0ac909853fe11 100644
--- a/GUI/coregui/Views/MaskWidgets/MaskEditor.cpp
+++ b/GUI/coregui/Views/MaskWidgets/MaskEditor.cpp
@@ -52,7 +52,7 @@ void MaskEditor::setMaskContext(SessionModel* model, const QModelIndex& maskCont
Q_ASSERT(intensityItem);
Q_ASSERT(maskContainerIndex.isValid());
- Q_ASSERT(model->itemForIndex(maskContainerIndex)->modelType() == Constants::MaskContainerType);
+ Q_ASSERT(model->itemForIndex(maskContainerIndex)->modelType() == "MaskContainer");
m_editorCanvas->setSelectionModel(m_editorPropertyPanel->selectionModel());
m_editorCanvas->setMaskContext(model, maskContainerIndex, intensityItem);
diff --git a/GUI/coregui/Views/MaskWidgets/MaskEditorCanvas.cpp b/GUI/coregui/Views/MaskWidgets/MaskEditorCanvas.cpp
index 26a60e7b693df89c0b012148f57e77d9b5b5f94c..787d72d18fedc2943b68414a24e1f204e85514b0 100644
--- a/GUI/coregui/Views/MaskWidgets/MaskEditorCanvas.cpp
+++ b/GUI/coregui/Views/MaskWidgets/MaskEditorCanvas.cpp
@@ -127,7 +127,7 @@ bool MaskEditorCanvas::isAxisRangeMatchData() const
void MaskEditorCanvas::setZoomToROI()
{
if (MaskContainerItem* maskContainer = m_intensityDataItem->maskContainerItem()) {
- if (SessionItem* roiItem = maskContainer->getChildOfType(Constants::RegionOfInterestType)) {
+ if (SessionItem* roiItem = maskContainer->getChildOfType("RegionOfInterest")) {
m_intensityDataItem->setLowerX(roiItem->getItemValue(RectangleItem::P_XLOW).toDouble());
m_intensityDataItem->setUpperX(roiItem->getItemValue(RectangleItem::P_XUP).toDouble());
m_intensityDataItem->setLowerY(roiItem->getItemValue(RectangleItem::P_YLOW).toDouble());
diff --git a/GUI/coregui/Views/MaskWidgets/MaskGraphicsScene.cpp b/GUI/coregui/Views/MaskWidgets/MaskGraphicsScene.cpp
index 93def02a6f49c32d4563d02b8745a7803a4b3574..4d081dcff5f40be5037e3fe817b5370fbf7cf799 100644
--- a/GUI/coregui/Views/MaskWidgets/MaskGraphicsScene.cpp
+++ b/GUI/coregui/Views/MaskWidgets/MaskGraphicsScene.cpp
@@ -17,7 +17,6 @@
#include "GUI/coregui/Models/MaskItems.h"
#include "GUI/coregui/Models/SessionItem.h"
#include "GUI/coregui/Models/SessionModel.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/MaskWidgets/ColorMapSceneAdaptor.h"
#include "GUI/coregui/Views/MaskWidgets/ISceneAdaptor.h"
#include "GUI/coregui/Views/MaskWidgets/IShape2DView.h"
@@ -74,8 +73,8 @@ void MaskGraphicsScene::setMaskContext(SessionModel* model, const QModelIndex& m
m_maskModel = model;
QString containerType = m_maskModel->itemForIndex(maskContainerIndex)->modelType();
- if (containerType != Constants::MaskContainerType
- && containerType != Constants::ProjectionContainerType)
+ if (containerType != "MaskContainer"
+ && containerType != "ProjectionContainer")
throw GUIHelpers::Error(
"MaskGraphicsScene::setMaskContext() -> Error. Not a container");
@@ -380,8 +379,8 @@ void MaskGraphicsScene::updateViews(const QModelIndex& parentIndex, IShape2DView
for (int i_row = 0; i_row < m_maskModel->rowCount(parentIndex); ++i_row) {
QModelIndex itemIndex = m_maskModel->index(i_row, 0, parentIndex);
if (SessionItem* item = m_maskModel->itemForIndex(itemIndex)) {
- if (item->modelType() == Constants::GroupItemType
- || item->modelType() == Constants::PropertyType)
+ if (item->modelType() == "GroupProperty"
+ || item->modelType() == "Property")
continue;
childView = addViewForItem(item);
@@ -469,7 +468,7 @@ bool MaskGraphicsScene::isValidForRectangleShapeDrawing(QGraphicsSceneMouseEvent
if (m_context.isROIMode()) {
// only one ROI is allowed
for (SessionItem* item : m_ItemToView.keys())
- if (item->modelType() == Constants::RegionOfInterestType)
+ if (item->modelType() == "RegionOfInterest")
return false;
}
return true;
@@ -519,7 +518,7 @@ bool MaskGraphicsScene::isValidForMaskAllDrawing(QGraphicsSceneMouseEvent* event
if (!m_context.isMaskAllMode())
return false;
for (SessionItem* item : m_ItemToView.keys())
- if (item->modelType() == Constants::MaskAllType)
+ if (item->modelType() == "MaskAllMask")
return false;
return true;
}
@@ -568,9 +567,9 @@ void MaskGraphicsScene::setInPanAndZoomMode(bool value)
void MaskGraphicsScene::updateCursors()
{
for (auto it = m_ItemToView.begin(); it != m_ItemToView.end(); ++it) {
- if (it.key()->modelType() == Constants::VerticalLineMaskType) {
+ if (it.key()->modelType() == "VerticalLineMask") {
it.value()->setCursor(m_context.isInZoomMode() ? Qt::ArrowCursor : Qt::SizeHorCursor);
- } else if (it.key()->modelType() == Constants::HorizontalLineMaskType) {
+ } else if (it.key()->modelType() == "HorizontalLineMask") {
it.value()->setCursor(m_context.isInZoomMode() ? Qt::ArrowCursor : Qt::SizeVerCursor);
}
}
@@ -611,13 +610,13 @@ void MaskGraphicsScene::processRectangleShapeItem(QGraphicsSceneMouseEvent* even
qreal ymin = std::min(click_pos.y(), mouse_pos.y());
qreal ymax = std::max(click_pos.y(), mouse_pos.y());
- if (m_currentItem->modelType() == Constants::RectangleMaskType
- || m_currentItem->modelType() == Constants::RegionOfInterestType) {
+ if (m_currentItem->modelType() == "RectangleMask"
+ || m_currentItem->modelType() == "RegionOfInterest") {
m_currentItem->setItemValue(RectangleItem::P_XLOW, m_adaptor->fromSceneX(xmin));
m_currentItem->setItemValue(RectangleItem::P_YLOW, m_adaptor->fromSceneY(ymax));
m_currentItem->setItemValue(RectangleItem::P_XUP, m_adaptor->fromSceneX(xmax));
m_currentItem->setItemValue(RectangleItem::P_YUP, m_adaptor->fromSceneY(ymin));
- } else if (m_currentItem->modelType() == Constants::EllipseMaskType) {
+ } else if (m_currentItem->modelType() == "EllipseMask") {
m_currentItem->setItemValue(EllipseItem::P_XCENTER,
m_adaptor->fromSceneX(xmin + (xmax - xmin) / 2.));
m_currentItem->setItemValue(EllipseItem::P_YCENTER,
@@ -638,14 +637,14 @@ void MaskGraphicsScene::processPolygonItem(QGraphicsSceneMouseEvent* event)
if (!m_currentItem) {
setDrawingInProgress(true);
m_currentItem =
- m_maskModel->insertNewItem(Constants::PolygonMaskType, m_maskContainerIndex, 0);
+ m_maskModel->insertNewItem("PolygonMask", m_maskContainerIndex, 0);
m_currentItem->setItemValue(MaskItem::P_MASK_VALUE, m_context.getMaskValue());
m_selectionModel->clearSelection();
m_selectionModel->select(m_maskModel->indexOfItem(m_currentItem),
QItemSelectionModel::Select);
setItemName(m_currentItem);
}
- Q_ASSERT(m_currentItem->modelType() == Constants::PolygonMaskType);
+ Q_ASSERT(m_currentItem->modelType() == "PolygonMask");
if (PolygonView* polygon = currentPolygon()) {
if (polygon->closePolygonIfNecessary()) {
@@ -654,7 +653,7 @@ void MaskGraphicsScene::processPolygonItem(QGraphicsSceneMouseEvent* event)
return;
}
}
- SessionItem* point = m_maskModel->insertNewItem(Constants::PolygonPointType,
+ SessionItem* point = m_maskModel->insertNewItem("PolygonPoint",
m_maskModel->indexOfItem(m_currentItem));
QPointF click_pos = event->buttonDownScenePos(Qt::LeftButton);
@@ -684,14 +683,14 @@ void MaskGraphicsScene::processLineItem(QGraphicsSceneMouseEvent* event)
void MaskGraphicsScene::processVerticalLineItem(const QPointF& pos)
{
m_currentItem =
- m_maskModel->insertNewItem(Constants::VerticalLineMaskType, m_maskContainerIndex, 0);
+ m_maskModel->insertNewItem("VerticalLineMask", m_maskContainerIndex, 0);
m_currentItem->setItemValue(VerticalLineItem::P_POSX, m_adaptor->fromSceneX(pos.x()));
}
void MaskGraphicsScene::processHorizontalLineItem(const QPointF& pos)
{
m_currentItem =
- m_maskModel->insertNewItem(Constants::HorizontalLineMaskType, m_maskContainerIndex, 0);
+ m_maskModel->insertNewItem("HorizontalLineMask", m_maskContainerIndex, 0);
m_currentItem->setItemValue(HorizontalLineItem::P_POSY, m_adaptor->fromSceneY(pos.y()));
}
@@ -699,7 +698,7 @@ void MaskGraphicsScene::processMaskAllItem(QGraphicsSceneMouseEvent* event)
{
Q_UNUSED(event);
setDrawingInProgress(true);
- m_currentItem = m_maskModel->insertNewItem(Constants::MaskAllType, m_maskContainerIndex);
+ m_currentItem = m_maskModel->insertNewItem("MaskAllMask", m_maskContainerIndex);
m_selectionModel->clearSelection();
setDrawingInProgress(false);
}
@@ -735,7 +734,7 @@ PolygonView* MaskGraphicsScene::currentPolygon() const
void MaskGraphicsScene::setItemName(SessionItem* itemToChange)
{
- if (itemToChange->modelType() == Constants::RegionOfInterestType)
+ if (itemToChange->modelType() == "RegionOfInterest")
return;
int glob_index(0);
diff --git a/GUI/coregui/Views/MaskWidgets/MaskResultsPresenter.cpp b/GUI/coregui/Views/MaskWidgets/MaskResultsPresenter.cpp
index 059baf1d277657bd78c12069bb7d34cae49c123e..a1f94755cbe35eafbd8bbbdd2488fc79f1706117 100644
--- a/GUI/coregui/Views/MaskWidgets/MaskResultsPresenter.cpp
+++ b/GUI/coregui/Views/MaskWidgets/MaskResultsPresenter.cpp
@@ -96,7 +96,7 @@ OutputData<double>* MaskResultsPresenter::createMaskPresentation() const
for (int i_row = m_maskModel->rowCount(m_maskContainerIndex); i_row > 0; --i_row) {
QModelIndex itemIndex = m_maskModel->index(i_row - 1, 0, m_maskContainerIndex);
if (MaskItem* maskItem = dynamic_cast<MaskItem*>(m_maskModel->itemForIndex(itemIndex))) {
- if (maskItem->modelType() == Constants::RegionOfInterestType) {
+ if (maskItem->modelType() == "RegionOfInterest") {
double xlow = maskItem->getItemValue(RectangleItem::P_XLOW).toDouble();
double ylow = maskItem->getItemValue(RectangleItem::P_YLOW).toDouble();
double xup = maskItem->getItemValue(RectangleItem::P_XUP).toDouble();
diff --git a/GUI/coregui/Views/MaskWidgets/MaskUnitsConverter.cpp b/GUI/coregui/Views/MaskWidgets/MaskUnitsConverter.cpp
index b839e9c31d71d0c49d154976ece74ca35127c93e..6bbbd90bf3bf49057dd5ad5209bfc495518c3e3a 100644
--- a/GUI/coregui/Views/MaskWidgets/MaskUnitsConverter.cpp
+++ b/GUI/coregui/Views/MaskWidgets/MaskUnitsConverter.cpp
@@ -60,18 +60,18 @@ void MaskUnitsConverter::convertIntensityDataItem(IntensityDataItem* intensityDa
void MaskUnitsConverter::convertMask(SessionItem* maskItem)
{
- if (maskItem->modelType() == Constants::RectangleMaskType
- || maskItem->modelType() == Constants::RegionOfInterestType) {
+ if (maskItem->modelType() == "RectangleMask"
+ || maskItem->modelType() == "RegionOfInterest") {
convertCoordinate(maskItem, RectangleItem::P_XLOW, RectangleItem::P_YLOW);
convertCoordinate(maskItem, RectangleItem::P_XUP, RectangleItem::P_YUP);
- } else if (maskItem->modelType() == Constants::PolygonMaskType) {
- for (SessionItem* pointItem : maskItem->getChildrenOfType(Constants::PolygonPointType))
+ } else if (maskItem->modelType() == "PolygonMask") {
+ for (SessionItem* pointItem : maskItem->getChildrenOfType("PolygonPoint"))
convertCoordinate(pointItem, PolygonPointItem::P_POSX, PolygonPointItem::P_POSY);
- } else if (maskItem->modelType() == Constants::VerticalLineMaskType) {
+ } else if (maskItem->modelType() == "VerticalLineMask") {
convertCoordinate(maskItem, VerticalLineItem::P_POSX, QString());
- } else if (maskItem->modelType() == Constants::HorizontalLineMaskType) {
+ } else if (maskItem->modelType() == "HorizontalLineMask") {
convertCoordinate(maskItem, QString(), HorizontalLineItem::P_POSY);
- } else if (maskItem->modelType() == Constants::EllipseMaskType) {
+ } else if (maskItem->modelType() == "EllipseMask") {
double xc = maskItem->getItemValue(EllipseItem::P_XCENTER).toDouble();
double yc = maskItem->getItemValue(EllipseItem::P_YCENTER).toDouble();
double xR = maskItem->getItemValue(EllipseItem::P_XRADIUS).toDouble();
diff --git a/GUI/coregui/Views/MaskWidgets/MaskViewFactory.cpp b/GUI/coregui/Views/MaskWidgets/MaskViewFactory.cpp
index 6b360b18513f36ef1d00ad1a3ddee2aec6ead0b0..7bf78aee22eaec8f96f951ab88a1ff5a51a33854 100644
--- a/GUI/coregui/Views/MaskWidgets/MaskViewFactory.cpp
+++ b/GUI/coregui/Views/MaskWidgets/MaskViewFactory.cpp
@@ -14,7 +14,6 @@
#include "GUI/coregui/Views/MaskWidgets/MaskViewFactory.h"
#include "GUI/coregui/Models/SessionItem.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/MaskWidgets/EllipseView.h"
#include "GUI/coregui/Views/MaskWidgets/IShape2DView.h"
#include "GUI/coregui/Views/MaskWidgets/IntensityDataView.h"
@@ -32,43 +31,43 @@ IShape2DView* MaskViewFactory::createMaskView(SessionItem* item, ISceneAdaptor*
IShape2DView* result(0);
QString model_type = item->modelType();
- if (model_type == Constants::MaskContainerType) {
+ if (model_type == "MaskContainer") {
result = new MaskContainerView();
}
- else if (model_type == Constants::ProjectionContainerType) {
+ else if (model_type == "ProjectionContainer") {
result = new MaskContainerView();
}
- else if (model_type == Constants::RectangleMaskType) {
+ else if (model_type == "RectangleMask") {
result = new RectangleView();
}
- else if (model_type == Constants::PolygonMaskType) {
+ else if (model_type == "PolygonMask") {
result = new PolygonView();
}
- else if (model_type == Constants::PolygonPointType) {
+ else if (model_type == "PolygonPoint") {
result = new PolygonPointView();
}
- else if (model_type == Constants::VerticalLineMaskType) {
+ else if (model_type == "VerticalLineMask") {
result = new VerticalLineView();
}
- else if (model_type == Constants::HorizontalLineMaskType) {
+ else if (model_type == "HorizontalLineMask") {
result = new HorizontalLineView();
}
- else if (model_type == Constants::EllipseMaskType) {
+ else if (model_type == "EllipseMask") {
result = new EllipseView();
}
- else if (model_type == Constants::MaskAllType) {
+ else if (model_type == "MaskAllMask") {
result = new MaskAllView();
}
- else if (model_type == Constants::RegionOfInterestType) {
+ else if (model_type == "RegionOfInterest") {
result = new RegionOfInterestView();
}
diff --git a/GUI/coregui/Views/MaskWidgets/PolygonView.cpp b/GUI/coregui/Views/MaskWidgets/PolygonView.cpp
index 299a4cff06db649091b35a71d18e325961e20109..2544a34aa201643473f9b36664dbd773bdf63ac3 100644
--- a/GUI/coregui/Views/MaskWidgets/PolygonView.cpp
+++ b/GUI/coregui/Views/MaskWidgets/PolygonView.cpp
@@ -137,7 +137,7 @@ void PolygonView::update_polygon()
m_polygon.clear();
- for (SessionItem* item : m_item->getChildrenOfType(Constants::PolygonPointType)) {
+ for (SessionItem* item : m_item->getChildrenOfType("PolygonPoint")) {
qreal px = toSceneX(item->getItemValue(PolygonPointItem::P_POSX).toReal());
qreal py = toSceneY(item->getItemValue(PolygonPointItem::P_POSY).toReal());
m_polygon << QPointF(px, py);
diff --git a/GUI/coregui/Views/MaterialEditor/MaterialItemUtils.cpp b/GUI/coregui/Views/MaterialEditor/MaterialItemUtils.cpp
index 4b970d1d4bc19b8f6829ab7ff30d850f2d5ffc21..be18c11c05c6689c0d2a0cbf7d9741d16b83efa3 100644
--- a/GUI/coregui/Views/MaterialEditor/MaterialItemUtils.cpp
+++ b/GUI/coregui/Views/MaterialEditor/MaterialItemUtils.cpp
@@ -38,10 +38,10 @@ namespace
std::map<QString, QString> get_tag_map()
{
std::map<QString, QString> result = {
- {Constants::ParticleCompositionType, ParticleCompositionItem::T_PARTICLES},
- {Constants::ParticleDistributionType, ParticleDistributionItem::T_PARTICLES},
- {Constants::ParticleLayoutType, ParticleLayoutItem::T_PARTICLES},
- {Constants::MesoCrystalType, MesoCrystalItem::T_BASIS_PARTICLE}};
+ {"ParticleComposition", ParticleCompositionItem::T_PARTICLES},
+ {"ParticleDistribution", ParticleDistributionItem::T_PARTICLES},
+ {"ParticleLayout", ParticleLayoutItem::T_PARTICLES},
+ {"MesoCrystal", MesoCrystalItem::T_BASIS_PARTICLE}};
return result;
}
} // namespace
@@ -110,9 +110,9 @@ MaterialItem* MaterialItemUtils::findMaterial(const ExternalProperty& material_p
QString MaterialItemUtils::materialTag(const SessionItem& item)
{
QString result;
- if (item.modelType() == Constants::ParticleType) {
+ if (item.modelType() == "Particle") {
result = ParticleItem::P_MATERIAL;
- } else if (item.modelType() == Constants::LayerType) {
+ } else if (item.modelType() == "Layer") {
result = LayerItem::P_MATERIAL;
}
return result;
@@ -122,7 +122,7 @@ QString MaterialItemUtils::materialTag(const SessionItem& item)
QStringList MaterialItemUtils::materialRelatedModelTypes()
{
- return {Constants::ParticleType, Constants::LayerType};
+ return {"Particle", "Layer"};
}
//! Constructs material property for given material.
@@ -200,9 +200,9 @@ QVector<SessionItem*> MaterialItemUtils::materialPropertyItems(SessionItem* item
continue;
}
- if (model_type == Constants::ParticleType)
+ if (model_type == "Particle")
materials.append(static_cast<ParticleItem*>(item)->materialPropertyItems());
- else if (model_type == Constants::ParticleCoreShellType)
+ else if (model_type == "ParticleCoreShell")
materials.append(static_cast<ParticleCoreShellItem*>(item)->materialPropertyItems());
else
throw GUIHelpers::Error(
diff --git a/GUI/coregui/Views/PropertyEditor/ComponentFlatView.cpp b/GUI/coregui/Views/PropertyEditor/ComponentFlatView.cpp
index 5e4c41590eecea50a696ccf23a7c4b11bec86cd3..9ab7bca9382f70f4a239aed281e09475521b678e 100644
--- a/GUI/coregui/Views/PropertyEditor/ComponentFlatView.cpp
+++ b/GUI/coregui/Views/PropertyEditor/ComponentFlatView.cpp
@@ -93,7 +93,7 @@ void ComponentFlatView::onDataChanged(const QModelIndex& topLeft, const QModelIn
Q_UNUSED(bottomRight);
SessionItem* item = m_model->itemForIndex(topLeft);
Q_ASSERT(item);
- if (item->modelType() == Constants::GroupItemType)
+ if (item->modelType() == "GroupProperty")
updateItemProperties();
if (roles.contains(SessionFlags::FlagRole))
diff --git a/GUI/coregui/Views/PropertyEditor/ComponentTreeActions.cpp b/GUI/coregui/Views/PropertyEditor/ComponentTreeActions.cpp
index b59493344089d9b9f530a56d6814ecb0bcf2df6a..0125e5bc326c736820c802e41b3afb8cc4d0dec5 100644
--- a/GUI/coregui/Views/PropertyEditor/ComponentTreeActions.cpp
+++ b/GUI/coregui/Views/PropertyEditor/ComponentTreeActions.cpp
@@ -14,7 +14,6 @@
#include "GUI/coregui/Views/PropertyEditor/ComponentTreeActions.h"
#include "GUI/coregui/Models/SessionItem.h"
-#include "GUI/coregui/Models/item_constants.h"
#include <QAction>
#include <QMenu>
@@ -26,7 +25,7 @@ ComponentTreeActions::ComponentTreeActions(QObject* parent) : QObject(parent) {}
void ComponentTreeActions::onCustomContextMenuRequested(const QPoint& point, SessionItem& item)
{
- bool sc_editor = item.editorType() == Constants::ScientificEditorType;
+ bool sc_editor = item.editorType() == "ScientificDouble";
QMenu menu;
QAction* scientificAction = menu.addAction("Scientific presentation");
@@ -37,9 +36,9 @@ void ComponentTreeActions::onCustomContextMenuRequested(const QPoint& point, Ses
scientificAction->setChecked(sc_editor);
connect(scientificAction, &QAction::triggered, [&]() {
if (scientificAction->isChecked())
- item.setEditorType(Constants::ScientificEditorType);
+ item.setEditorType("ScientificDouble");
else
- item.setEditorType(Constants::DefaultEditorType);
+ item.setEditorType("Default");
});
// to select number of decimals
@@ -49,7 +48,7 @@ void ComponentTreeActions::onCustomContextMenuRequested(const QPoint& point, Ses
if (!sc_editor && item.decimals() == i)
action->setChecked(true);
connect(action, &QAction::triggered, [i, &item] {
- item.setEditorType(Constants::DefaultEditorType);
+ item.setEditorType("Default");
item.setDecimals(i);
});
}
diff --git a/GUI/coregui/Views/PropertyEditor/ComponentUtils.cpp b/GUI/coregui/Views/PropertyEditor/ComponentUtils.cpp
index 31001bf939d12f34bb06d857a8ca27f5f1091d56..fcabe722b7aace46d8db7673de28c35984761a5b 100644
--- a/GUI/coregui/Views/PropertyEditor/ComponentUtils.cpp
+++ b/GUI/coregui/Views/PropertyEditor/ComponentUtils.cpp
@@ -14,7 +14,6 @@
#include "GUI/coregui/Views/PropertyEditor/ComponentUtils.h"
#include "GUI/coregui/Models/SessionItem.h"
-#include "GUI/coregui/Models/item_constants.h"
namespace
{
@@ -24,9 +23,9 @@ QList<const SessionItem*> groupItems(const SessionItem& item);
QStringList ComponentUtils::propertyRelatedTypes()
{
QStringList result = QStringList()
- << Constants::PropertyType << Constants::GroupItemType
- << Constants::VectorType << Constants::BasicAxisType
- << Constants::AmplitudeAxisType << Constants::MaterialRefractiveDataType;
+ << "Property" << "GroupProperty"
+ << "Vector" << "BasicAxis"
+ << "AmplitudeAxis" << "MaterialRefractiveData";
return result;
}
@@ -36,10 +35,10 @@ QList<const SessionItem*> ComponentUtils::componentItems(const SessionItem& item
QList<const SessionItem*> result;
- if (item.modelType() == Constants::PropertyType) {
+ if (item.modelType() == "Property") {
result.push_back(&item);
- } else if (item.modelType() == Constants::GroupItemType) {
+ } else if (item.modelType() == "GroupProperty") {
result.push_back(&item);
result += groupItems(item);
@@ -52,7 +51,7 @@ QList<const SessionItem*> ComponentUtils::componentItems(const SessionItem& item
if (propertyRelated.contains(child->modelType()))
result.append(child);
- if (child->modelType() == Constants::GroupItemType)
+ if (child->modelType() == "GroupProperty")
result += groupItems(*child);
}
}
@@ -64,7 +63,7 @@ namespace
{
QList<const SessionItem*> groupItems(const SessionItem& item)
{
- Q_ASSERT(item.modelType() == Constants::GroupItemType);
+ Q_ASSERT(item.modelType() == "GroupProperty");
QList<const SessionItem*> result;
for (auto grandchild : item.children()) {
diff --git a/GUI/coregui/Views/PropertyEditor/CustomEditors.cpp b/GUI/coregui/Views/PropertyEditor/CustomEditors.cpp
index 82b18d53feafddd9a875991ab115410204892261..2c84d8cce6a9d3c939d8da3f1e495f1f141729d6 100644
--- a/GUI/coregui/Views/PropertyEditor/CustomEditors.cpp
+++ b/GUI/coregui/Views/PropertyEditor/CustomEditors.cpp
@@ -70,7 +70,7 @@ void CustomEditor::setDataIntern(const QVariant& data)
ExternalPropertyEditor::ExternalPropertyEditor(QWidget* parent)
: CustomEditor(parent), m_textLabel(new QLabel), m_pixmapLabel(new QLabel),
m_focusFilter(new LostFocusFilter(this)),
- m_extDialogType(Constants::MaterialEditorExternalType)
+ m_extDialogType("ExtMaterialEditor")
{
setMouseTracking(true);
setAutoFillBackground(true);
@@ -109,9 +109,9 @@ void ExternalPropertyEditor::buttonClicked()
ExternalProperty property = m_data.value<ExternalProperty>();
ExternalProperty newProperty;
- if (m_extDialogType == Constants::MaterialEditorExternalType) {
+ if (m_extDialogType == "ExtMaterialEditor") {
newProperty = MaterialItemUtils::selectMaterialProperty(property);
- } else if (m_extDialogType == Constants::ColorEditorExternalType) {
+ } else if (m_extDialogType == "ExtColorEditor") {
newProperty = MaterialItemUtils::selectColorProperty(property);
} else {
throw GUIHelpers::Error("ExternalPropertyEditor::buttonClicked() -> Unexpected dialog");
diff --git a/GUI/coregui/Views/PropertyEditor/PropertyEditorFactory.cpp b/GUI/coregui/Views/PropertyEditor/PropertyEditorFactory.cpp
index e42384ede4e621ca75cf85d5b66673344d1f69ef..a891374b79580c707e86a1488654632b21d08a74 100644
--- a/GUI/coregui/Views/PropertyEditor/PropertyEditorFactory.cpp
+++ b/GUI/coregui/Views/PropertyEditor/PropertyEditorFactory.cpp
@@ -91,9 +91,9 @@ QString PropertyEditorFactory::toString(const QModelIndex& index)
if (isDoubleProperty(variant) && index.internalPointer()) {
auto item = static_cast<SessionItem*>(index.internalPointer());
- return item->editorType() == Constants::ScientificEditorType
+ return item->editorType() == "ScientificDouble"
? QString::number(item->value().toDouble(), 'g')
- : item->editorType() == Constants::ScientificSpinBoxType
+ : item->editorType() == "ScientificSpinBox"
? ScientificSpinBox::toString(item->value().toDouble(), item->decimals())
: QString::number(item->value().toDouble(), 'f', item->decimals());
}
@@ -106,12 +106,12 @@ QWidget* PropertyEditorFactory::CreateEditor(const SessionItem& item, QWidget* p
QWidget* result(nullptr);
if (isDoubleProperty(item.value())) {
- if (item.editorType() == Constants::ScientificEditorType) {
+ if (item.editorType() == "ScientificDouble") {
auto editor = new ScientificDoublePropertyEditor;
auto limits = item.limits();
editor->setLimits(limits);
result = editor;
- } else if (item.editorType() == Constants::ScientificSpinBoxType) {
+ } else if (item.editorType() == "ScientificSpinBox") {
auto editor = new ScientificSpinBoxEditor;
auto limits = item.limits();
editor->setLimits(limits);
@@ -135,14 +135,14 @@ QWidget* PropertyEditorFactory::CreateEditor(const SessionItem& item, QWidget* p
result = createCustomStringEditor(item);
} else if (isExternalProperty(item.value())) {
auto editor = new ExternalPropertyEditor;
- if (item.editorType() != Constants::DefaultEditorType)
+ if (item.editorType() != "Default")
editor->setExternalDialogType(item.editorType());
result = editor;
} else if (isComboProperty(item.value())) {
- if (item.editorType() == Constants::DefaultEditorType) {
+ if (item.editorType() == "Default") {
auto editor = new ComboPropertyEditor;
result = editor;
- } else if (item.editorType() == Constants::MultiSelectionComboEditorType) {
+ } else if (item.editorType() == "MultiSelectionComboEditor") {
auto editor = new MultiComboPropertyEditor;
result = editor;
}
diff --git a/GUI/coregui/Views/PropertyEditor/TestComponentView.cpp b/GUI/coregui/Views/PropertyEditor/TestComponentView.cpp
index d44269ffe0dca42f851f410d3859b903400e8cf7..4dbf35e48f6679308ecab40f83900ea7f41247dd 100644
--- a/GUI/coregui/Views/PropertyEditor/TestComponentView.cpp
+++ b/GUI/coregui/Views/PropertyEditor/TestComponentView.cpp
@@ -22,7 +22,6 @@
#include "GUI/coregui/Models/MaterialModel.h"
#include "GUI/coregui/Models/SampleModel.h"
#include "GUI/coregui/Models/SessionModelDelegate.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/MaterialEditor/MaterialItemUtils.h"
#include "GUI/coregui/Views/PropertyEditor/ComponentEditor.h"
#include "GUI/coregui/Views/PropertyEditor/ComponentFlatView.h"
@@ -87,7 +86,7 @@ void TestComponentView::onUpdateRequest()
void TestComponentView::onAddItemRequest()
{
- m_sampleModel->insertNewItem(Constants::ParticleType);
+ m_sampleModel->insertNewItem("Particle");
}
void TestComponentView::onExpandRequest()
@@ -120,11 +119,11 @@ void TestComponentView::init_source()
const std::unique_ptr<MultiLayer> sample(
factory.createSample("CylindersWithSizeDistributionBuilder"));
GUIObjectBuilder::populateSampleModel(m_sampleModel, m_materialModel, *sample);
- m_sampleModel->insertNewItem(Constants::VectorType);
- m_sampleModel->insertNewItem(Constants::GISASBeamType);
+ m_sampleModel->insertNewItem("Vector");
+ m_sampleModel->insertNewItem("GISASBeam");
// adding intensity data item
- m_sampleModel->insertNewItem(Constants::IntensityDataType);
+ m_sampleModel->insertNewItem("IntensityData");
}
void TestComponentView::onSelectionChanged(const QItemSelection& selected, const QItemSelection&)
diff --git a/GUI/coregui/Views/RealSpaceWidgets/RealSpaceBuilder.cpp b/GUI/coregui/Views/RealSpaceWidgets/RealSpaceBuilder.cpp
index 414124fd20c23ba2a9c30a57a98f6dbd661fc911..b8df2905fb767460c7e7f24af2cccf5b5da4353a 100644
--- a/GUI/coregui/Views/RealSpaceWidgets/RealSpaceBuilder.cpp
+++ b/GUI/coregui/Views/RealSpaceWidgets/RealSpaceBuilder.cpp
@@ -56,28 +56,28 @@ void RealSpaceBuilder::populate(RealSpaceModel* model, const SessionItem& item,
model->defCamPos = cameraPosition;
- if (item.modelType() == Constants::MultiLayerType)
+ if (item.modelType() == "MultiLayer")
populateMultiLayer(model, item, sceneGeometry);
- else if (item.modelType() == Constants::LayerType)
+ else if (item.modelType() == "Layer")
populateLayer(model, item, sceneGeometry);
- else if (item.modelType() == Constants::ParticleLayoutType)
+ else if (item.modelType() == "ParticleLayout")
populateLayout(model, item, sceneGeometry);
- else if (item.modelType() == Constants::ParticleType)
+ else if (item.modelType() == "Particle")
populateParticleFromParticleItem(model, item);
- else if (item.modelType() == Constants::ParticleCompositionType)
+ else if (item.modelType() == "ParticleComposition")
populateParticleFromParticleItem(model, item);
- else if (item.modelType() == Constants::ParticleCoreShellType)
+ else if (item.modelType() == "ParticleCoreShell")
populateParticleFromParticleItem(model, item);
- else if (item.modelType() == Constants::ParticleDistributionType)
+ else if (item.modelType() == "ParticleDistribution")
populateParticleFromParticleItem(model, item);
- else if (item.modelType() == Constants::MesoCrystalType)
+ else if (item.modelType() == "MesoCrystal")
populateParticleFromParticleItem(model, item);
}
@@ -114,7 +114,7 @@ void RealSpaceBuilder::populateLayer(RealSpaceModel* model, const SessionItem& l
void RealSpaceBuilder::populateLayout(RealSpaceModel* model, const SessionItem& layoutItem,
const SceneGeometry& sceneGeometry, const QVector3D& origin)
{
- Q_ASSERT(layoutItem.modelType() == Constants::ParticleLayoutType);
+ Q_ASSERT(layoutItem.modelType() == "ParticleLayout");
// If there is no particle to populate
if (!layoutItem.getItem(ParticleLayoutItem::T_PARTICLES))
@@ -140,11 +140,11 @@ void RealSpaceBuilder::populateParticleFromParticleItem(RealSpaceModel* model,
const SessionItem& particleItem) const
{
Particle3DContainer particle3DContainer;
- if (particleItem.modelType() == Constants::ParticleType) {
+ if (particleItem.modelType() == "Particle") {
auto pItem = dynamic_cast<const ParticleItem*>(&particleItem);
auto particle = pItem->createParticle();
particle3DContainer = RealSpaceBuilderUtils::singleParticle3DContainer(*particle);
- } else if (particleItem.modelType() == Constants::ParticleCoreShellType) {
+ } else if (particleItem.modelType() == "ParticleCoreShell") {
auto particleCoreShellItem = dynamic_cast<const ParticleCoreShellItem*>(&particleItem);
// If there is no CORE or SHELL to populate inside ParticleCoreShellItem
if (!particleCoreShellItem->getItem(ParticleCoreShellItem::T_CORE)
@@ -153,7 +153,7 @@ void RealSpaceBuilder::populateParticleFromParticleItem(RealSpaceModel* model,
auto particleCoreShell = particleCoreShellItem->createParticleCoreShell();
particle3DContainer =
RealSpaceBuilderUtils::particleCoreShell3DContainer(*particleCoreShell);
- } else if (particleItem.modelType() == Constants::ParticleCompositionType) {
+ } else if (particleItem.modelType() == "ParticleComposition") {
auto particleCompositionItem = dynamic_cast<const ParticleCompositionItem*>(&particleItem);
// If there is no particle to populate inside ParticleCompositionItem
if (!particleCompositionItem->getItem(ParticleCompositionItem::T_PARTICLES))
@@ -161,14 +161,14 @@ void RealSpaceBuilder::populateParticleFromParticleItem(RealSpaceModel* model,
auto particleComposition = particleCompositionItem->createParticleComposition();
particle3DContainer =
RealSpaceBuilderUtils::particleComposition3DContainer(*particleComposition);
- } else if (particleItem.modelType() == Constants::ParticleDistributionType) {
+ } else if (particleItem.modelType() == "ParticleDistribution") {
auto particleDistributionItem =
dynamic_cast<const ParticleDistributionItem*>(&particleItem);
// If there is no particle to populate inside ParticleDistributionItem
if (!particleDistributionItem->getItem(ParticleDistributionItem::T_PARTICLES))
return;
// show nothing when ParticleDistributionItem is selected
- } else if (particleItem.modelType() == Constants::MesoCrystalType) {
+ } else if (particleItem.modelType() == "MesoCrystal") {
auto mesoCrystalItem = dynamic_cast<const MesoCrystalItem*>(&particleItem);
// If there is no particle to populate inside MesoCrystalItem
if (!mesoCrystalItem->getItem(MesoCrystalItem::T_BASIS_PARTICLE))
diff --git a/GUI/coregui/Views/RealSpaceWidgets/RealSpaceBuilderUtils.cpp b/GUI/coregui/Views/RealSpaceWidgets/RealSpaceBuilderUtils.cpp
index 73ddff2cad5a3cf0ebf8147832bfdb0a8ccb3e85..4992093946b1280fc795ae348dcc73cedc1780d2 100644
--- a/GUI/coregui/Views/RealSpaceWidgets/RealSpaceBuilderUtils.cpp
+++ b/GUI/coregui/Views/RealSpaceWidgets/RealSpaceBuilderUtils.cpp
@@ -232,11 +232,11 @@ RealSpaceBuilderUtils::particle3DContainerVector(const SessionItem& layoutItem,
Particle3DContainer particle3DContainer;
- if (particleItem->modelType() == Constants::ParticleType) {
+ if (particleItem->modelType() == "Particle") {
auto pItem = dynamic_cast<const ParticleItem*>(particleItem);
auto particle = pItem->createParticle();
particle3DContainer = singleParticle3DContainer(*particle, total_abundance, origin);
- } else if (particleItem->modelType() == Constants::ParticleCoreShellType) {
+ } else if (particleItem->modelType() == "ParticleCoreShell") {
auto particleCoreShellItem = dynamic_cast<const ParticleCoreShellItem*>(particleItem);
// If there is no CORE or SHELL to populate inside ParticleCoreShellItem
if (!particleCoreShellItem->getItem(ParticleCoreShellItem::T_CORE)
@@ -245,7 +245,7 @@ RealSpaceBuilderUtils::particle3DContainerVector(const SessionItem& layoutItem,
auto particleCoreShell = particleCoreShellItem->createParticleCoreShell();
particle3DContainer =
particleCoreShell3DContainer(*particleCoreShell, total_abundance, origin);
- } else if (particleItem->modelType() == Constants::ParticleCompositionType) {
+ } else if (particleItem->modelType() == "ParticleComposition") {
auto particleCompositionItem =
dynamic_cast<const ParticleCompositionItem*>(particleItem);
// If there is no particle to populate inside ParticleCompositionItem
@@ -254,7 +254,7 @@ RealSpaceBuilderUtils::particle3DContainerVector(const SessionItem& layoutItem,
auto particleComposition = particleCompositionItem->createParticleComposition();
particle3DContainer =
particleComposition3DContainer(*particleComposition, total_abundance, origin);
- } else if (particleItem->modelType() == Constants::ParticleDistributionType) {
+ } else if (particleItem->modelType() == "ParticleDistribution") {
auto particleDistributionItem =
dynamic_cast<const ParticleDistributionItem*>(particleItem);
// If there is no particle to populate inside ParticleDistributionItem
@@ -269,7 +269,7 @@ RealSpaceBuilderUtils::particle3DContainerVector(const SessionItem& layoutItem,
particle3DContainer_vector.emplace_back(std::move(pd_ContainerVector[i]));
}
continue;
- } else if (particleItem->modelType() == Constants::MesoCrystalType) {
+ } else if (particleItem->modelType() == "MesoCrystal") {
auto mesoCrystalItem = dynamic_cast<const MesoCrystalItem*>(particleItem);
// If there is no particle to populate inside MesoCrystalItem
if (!mesoCrystalItem->getItem(MesoCrystalItem::T_BASIS_PARTICLE))
@@ -302,7 +302,7 @@ Particle3DContainer RealSpaceBuilderUtils::singleParticle3DContainer(const Parti
Particle3DContainer singleParticle3DContainer;
singleParticle3DContainer.addParticle(particle3D.release(), false);
singleParticle3DContainer.setCumulativeAbundance(P_clone->abundance() / total_abundance);
- singleParticle3DContainer.setParticleType(Constants::ParticleType);
+ singleParticle3DContainer.setParticleType("Particle");
return singleParticle3DContainer;
}
@@ -340,7 +340,7 @@ RealSpaceBuilderUtils::particleCoreShell3DContainer(const ParticleCoreShell& par
particleCoreShell3DContainer.addParticle(coreParticle3D.release(), false); // index 0
particleCoreShell3DContainer.addParticle(shellParticle3D.release(), true); // index 1
particleCoreShell3DContainer.setCumulativeAbundance(PCS_clone->abundance() / total_abundance);
- particleCoreShell3DContainer.setParticleType(Constants::ParticleCoreShellType);
+ particleCoreShell3DContainer.setParticleType("ParticleCoreShell");
return particleCoreShell3DContainer;
}
@@ -381,7 +381,7 @@ Particle3DContainer RealSpaceBuilderUtils::particleComposition3DContainer(
}
// set the correct abundance for the entire ParticleComposition
particleComposition3DContainer.setCumulativeAbundance(PC_clone->abundance() / total_abundance);
- particleComposition3DContainer.setParticleType(Constants::ParticleCompositionType);
+ particleComposition3DContainer.setParticleType("ParticleComposition");
return particleComposition3DContainer;
}
diff --git a/GUI/coregui/Views/RealSpaceWidgets/RealSpaceMesoCrystalUtils.cpp b/GUI/coregui/Views/RealSpaceWidgets/RealSpaceMesoCrystalUtils.cpp
index e75d7acf723bb4685bbdceae8d88a71115d06b3b..cdafa3be7d07c395977b7062f64458792bb80551 100644
--- a/GUI/coregui/Views/RealSpaceWidgets/RealSpaceMesoCrystalUtils.cpp
+++ b/GUI/coregui/Views/RealSpaceWidgets/RealSpaceMesoCrystalUtils.cpp
@@ -445,7 +445,7 @@ Particle3DContainer RealSpaceMesoCrystal::populateMesoCrystal()
// set the correct abundance for the MesoCrystal
mesoCrystal3DContainer.setCumulativeAbundance(M_clone->abundance() / m_total_abundance);
- mesoCrystal3DContainer.setParticleType(Constants::MesoCrystalType);
+ mesoCrystal3DContainer.setParticleType("MesoCrystal");
return mesoCrystal3DContainer;
}
diff --git a/GUI/coregui/Views/RealSpaceWidgets/TransformTo3D.cpp b/GUI/coregui/Views/RealSpaceWidgets/TransformTo3D.cpp
index c54878d0066c5b95c69691ae393429066095ea78..1bb0473fec5d11328a328dd732f994fb0ac91664 100644
--- a/GUI/coregui/Views/RealSpaceWidgets/TransformTo3D.cpp
+++ b/GUI/coregui/Views/RealSpaceWidgets/TransformTo3D.cpp
@@ -44,7 +44,7 @@ bool isBottomLayer(const SessionItem& layerItem)
double TransformTo3D::visualLayerThickness(const SessionItem& layerItem,
const SceneGeometry& sceneGeometry)
{
- Q_ASSERT(layerItem.modelType() == Constants::LayerType);
+ Q_ASSERT(layerItem.modelType() == "Layer");
double thickness(0.0);
if (isTopLayer(layerItem))
@@ -61,7 +61,7 @@ std::unique_ptr<RealSpace::Layer> TransformTo3D::createLayer(const SessionItem&
const SceneGeometry& sceneGeometry,
const QVector3D& origin)
{
- Q_ASSERT(layerItem.modelType() == Constants::LayerType);
+ Q_ASSERT(layerItem.modelType() == "Layer");
double thickness = TransformTo3D::visualLayerThickness(layerItem, sceneGeometry);
@@ -86,7 +86,7 @@ std::unique_ptr<RealSpace::Layer> TransformTo3D::createLayer(const SessionItem&
std::unique_ptr<RealSpace::Particles::Particle>
TransformTo3D::createParticle3D(const SessionItem& particleItem)
{
- Q_ASSERT(particleItem.modelType() == Constants::ParticleType);
+ Q_ASSERT(particleItem.modelType() == "Particle");
std::unique_ptr<RealSpace::Particles::Particle> result;
diff --git a/GUI/coregui/Views/SampleDesigner/DesignerHelper.cpp b/GUI/coregui/Views/SampleDesigner/DesignerHelper.cpp
index 67d3ecd0116c93c062d64b2d962a3b371573ddae..245107d3d83e7206f2327fa466aeac4ec136798c 100644
--- a/GUI/coregui/Views/SampleDesigner/DesignerHelper.cpp
+++ b/GUI/coregui/Views/SampleDesigner/DesignerHelper.cpp
@@ -13,7 +13,6 @@
// ************************************************************************** //
#include "GUI/coregui/Views/SampleDesigner/DesignerHelper.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/utils/StyleUtils.h"
#include <QPainter>
#include <QtGlobal>
@@ -154,17 +153,17 @@ int DesignerHelper::nanometerToScreen(double nanometer)
QRectF DesignerHelper::getDefaultBoundingRect(const QString& name)
{
- if (name == Constants::MultiLayerType) {
+ if (name == "MultiLayer") {
return getDefaultMultiLayerRect();
- } else if (name == Constants::LayerType) {
+ } else if (name == "Layer") {
return QRectF(0, 0, layerWidth(), layerHeight());
- } else if (name == Constants::ParticleLayoutType) {
+ } else if (name == "ParticleLayout") {
return getParticleLayoutBoundingRect();
- } else if (name == Constants::RotationType) {
+ } else if (name == "Rotation") {
return getTransformationBoundingRect();
- } else if (name.startsWith(Constants::FormFactorType) || name == Constants::ParticleType
- || name == Constants::ParticleCoreShellType
- || name == Constants::ParticleDistributionType) {
+ } else if (name.startsWith("FormFactor") || name == "Particle"
+ || name == "ParticleCoreShell"
+ || name == "ParticleDistribution") {
return getParticleBoundingRect();
} else if (name.startsWith("Interference")) {
return getInterferenceFunctionBoundingRect();
@@ -175,16 +174,16 @@ QRectF DesignerHelper::getDefaultBoundingRect(const QString& name)
QColor DesignerHelper::getDefaultColor(const QString& name)
{
- if (name == Constants::MultiLayerType) {
+ if (name == "MultiLayer") {
// return QColor(Qt::blue);
return QColor(51, 116, 255);
- } else if (name == Constants::LayerType) {
+ } else if (name == "Layer") {
// return QColor(Qt::green);
return QColor(26, 156, 9);
- } else if (name == Constants::ParticleLayoutType) {
+ } else if (name == "ParticleLayout") {
return QColor(135, 206, 50);
- } else if (name.startsWith(Constants::FormFactorType) || name == Constants::ParticleType
- || name == Constants::ParticleCoreShellType) {
+ } else if (name.startsWith("FormFactor") || name == "Particle"
+ || name == "ParticleCoreShell") {
return QColor(210, 223, 237);
} else if (name.startsWith("InterferenceFunction")) {
return QColor(255, 236, 139);
diff --git a/GUI/coregui/Views/SampleDesigner/DesignerScene.cpp b/GUI/coregui/Views/SampleDesigner/DesignerScene.cpp
index 76156719e7471c04014b085f300131d3196d33d6..a538f682dec29333496c834e1666e0904cf841ba 100644
--- a/GUI/coregui/Views/SampleDesigner/DesignerScene.cpp
+++ b/GUI/coregui/Views/SampleDesigner/DesignerScene.cpp
@@ -348,11 +348,11 @@ void DesignerScene::onEstablishedConnection(NodeEditorConnection* connection)
ConnectableView* childView = connection->getChildView();
QString tag;
- if (connection->getParentView()->getItem()->modelType() == Constants::ParticleLayoutType) {
+ if (connection->getParentView()->getItem()->modelType() == "ParticleLayout") {
if (connection->inputPort()->getPortType() == NodeEditorPort::INTERFERENCE)
tag = ParticleLayoutItem::T_INTERFERENCE;
} else if (connection->getParentView()->getItem()->modelType()
- == Constants::ParticleCoreShellType) {
+ == "ParticleCoreShell") {
if (parentView->getInputPortIndex(connection->inputPort()) == 0)
tag = ParticleCoreShellItem::T_CORE;
else if (parentView->getInputPortIndex(connection->inputPort()) == 1)
@@ -361,10 +361,10 @@ void DesignerScene::onEstablishedConnection(NodeEditorConnection* connection)
tag = ParticleItem::T_TRANSFORMATION;
} else if (connection->getParentView()->getItem()->modelType()
- == Constants::ParticleCompositionType) {
+ == "ParticleComposition") {
if (connection->inputPort()->getPortType() == NodeEditorPort::TRANSFORMATION)
tag = ParticleItem::T_TRANSFORMATION;
- } else if (connection->getParentView()->getItem()->modelType() == Constants::MesoCrystalType) {
+ } else if (connection->getParentView()->getItem()->modelType() == "MesoCrystal") {
if (connection->inputPort()->getPortType() == NodeEditorPort::TRANSFORMATION)
tag = ParticleItem::T_TRANSFORMATION;
}
@@ -413,10 +413,10 @@ void DesignerScene::dropEvent(QGraphicsSceneDragDropEvent* event)
if (SampleViewFactory::isValidType(mimeData->getClassName())) {
SessionItem* new_item(0);
- if (mimeData->getClassName().startsWith(Constants::FormFactorType)) {
- new_item = m_sampleModel->insertNewItem(Constants::ParticleType);
+ if (mimeData->getClassName().startsWith("FormFactor")) {
+ new_item = m_sampleModel->insertNewItem("Particle");
QString ffName = mimeData->getClassName();
- ffName.remove(Constants::FormFactorType);
+ ffName.remove("FormFactor");
new_item->setGroupProperty(ParticleItem::P_FORM_FACTOR, ffName);
} else {
@@ -492,12 +492,12 @@ bool DesignerScene::isAcceptedByMultiLayer(const DesignerMimeData* mimeData,
return false;
// // MultiLayer can be inserted in MultiLayer
- // if (mimeData->getClassName() == Constants::MultiLayerType && isMultiLayerNearby(event)) {
+ // if (mimeData->getClassName() == "MultiLayer" && isMultiLayerNearby(event)) {
// return true;
// }
// layer can be inserted in MultiLayer
- if (mimeData->getClassName() == Constants::LayerType && isMultiLayerNearby(event)) {
+ if (mimeData->getClassName() == "Layer" && isMultiLayerNearby(event)) {
return true;
}
return false;
diff --git a/GUI/coregui/Views/SampleDesigner/InterferenceFunctionViews.cpp b/GUI/coregui/Views/SampleDesigner/InterferenceFunctionViews.cpp
index 007a1361c1ed5fa121e8bbb54eb0c2bf22314518..130b212f1a385a14c9dd4860060f7f91c58d2589 100644
--- a/GUI/coregui/Views/SampleDesigner/InterferenceFunctionViews.cpp
+++ b/GUI/coregui/Views/SampleDesigner/InterferenceFunctionViews.cpp
@@ -13,13 +13,12 @@
// ************************************************************************** //
#include "GUI/coregui/Views/SampleDesigner/InterferenceFunctionViews.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/SampleDesigner/DesignerHelper.h"
InterferenceFunction1DLatticeView::InterferenceFunction1DLatticeView(QGraphicsItem* parent)
: ConnectableView(parent)
{
- setName(Constants::InterferenceFunction1DLatticeType);
+ setName("Interference1DLattice");
setColor(QColor(255, 236, 139));
setRectangle(DesignerHelper::getInterferenceFunctionBoundingRect());
addPort("out", NodeEditorPort::OUTPUT, NodeEditorPort::INTERFERENCE);
@@ -29,7 +28,7 @@ InterferenceFunction1DLatticeView::InterferenceFunction1DLatticeView(QGraphicsIt
InterferenceFunction2DLatticeView::InterferenceFunction2DLatticeView(QGraphicsItem* parent)
: ConnectableView(parent)
{
- setName(Constants::InterferenceFunction2DLatticeType);
+ setName("Interference2DLattice");
setColor(QColor(255, 236, 139));
setRectangle(DesignerHelper::getInterferenceFunctionBoundingRect());
addPort("out", NodeEditorPort::OUTPUT, NodeEditorPort::INTERFERENCE);
@@ -39,7 +38,7 @@ InterferenceFunction2DLatticeView::InterferenceFunction2DLatticeView(QGraphicsIt
InterferenceFunction2DParaCrystalView::InterferenceFunction2DParaCrystalView(QGraphicsItem* parent)
: ConnectableView(parent)
{
- setName(Constants::InterferenceFunction2DParaCrystalType);
+ setName("Interference2DParaCrystal");
setColor(QColor(255, 236, 139));
setRectangle(DesignerHelper::getInterferenceFunctionBoundingRect());
addPort("out", NodeEditorPort::OUTPUT, NodeEditorPort::INTERFERENCE);
@@ -50,7 +49,7 @@ InterferenceFunctionFinite2DLatticeView::InterferenceFunctionFinite2DLatticeView
QGraphicsItem* parent)
: ConnectableView(parent)
{
- setName(Constants::InterferenceFunctionFinite2DLatticeType);
+ setName("InterferenceFinite2DLattice");
setColor(QColor(255, 236, 139));
setRectangle(DesignerHelper::getInterferenceFunctionBoundingRect());
addPort("out", NodeEditorPort::OUTPUT, NodeEditorPort::INTERFERENCE);
@@ -60,7 +59,7 @@ InterferenceFunctionFinite2DLatticeView::InterferenceFunctionFinite2DLatticeView
InterferenceFunctionHardDiskView::InterferenceFunctionHardDiskView(QGraphicsItem* parent)
: ConnectableView(parent)
{
- setName(Constants::InterferenceFunctionHardDiskType);
+ setName("InterferenceHardDisk");
setColor(QColor(255, 236, 139));
setRectangle(DesignerHelper::getInterferenceFunctionBoundingRect());
addPort("out", NodeEditorPort::OUTPUT, NodeEditorPort::INTERFERENCE);
@@ -71,7 +70,7 @@ InterferenceFunctionRadialParaCrystalView::InterferenceFunctionRadialParaCrystal
QGraphicsItem* parent)
: ConnectableView(parent)
{
- setName(Constants::InterferenceFunctionRadialParaCrystalType);
+ setName("InterferenceRadialParaCrystal");
setColor(QColor(255, 236, 139));
setRectangle(DesignerHelper::getInterferenceFunctionBoundingRect());
addPort("out", NodeEditorPort::OUTPUT, NodeEditorPort::INTERFERENCE);
diff --git a/GUI/coregui/Views/SampleDesigner/LayerView.cpp b/GUI/coregui/Views/SampleDesigner/LayerView.cpp
index 40964fd92f71471ecdd7d0e044cbaa1fa10176b7..9aa1bd485055425b30ee29536284c8e5ec7eb71c 100644
--- a/GUI/coregui/Views/SampleDesigner/LayerView.cpp
+++ b/GUI/coregui/Views/SampleDesigner/LayerView.cpp
@@ -25,8 +25,8 @@
LayerView::LayerView(QGraphicsItem* parent) : ILayerView(parent)
{
setColor(QColor(qrand() % 256, qrand() % 256, qrand() % 256));
- setName(Constants::LayerType);
- setRectangle(DesignerHelper::getDefaultBoundingRect(Constants::LayerType));
+ setName("Layer");
+ setRectangle(DesignerHelper::getDefaultBoundingRect("Layer"));
setAcceptDrops(false);
addPort(QString(), NodeEditorPort::INPUT, NodeEditorPort::PARTICLE_LAYOUT);
}
diff --git a/GUI/coregui/Views/SampleDesigner/MesoCrystalView.cpp b/GUI/coregui/Views/SampleDesigner/MesoCrystalView.cpp
index 6c379d9ccf7280a6354bf543bb171d463292d4c5..4cd2054e9fc2b0618a360a0bb26e3d0c433f8352 100644
--- a/GUI/coregui/Views/SampleDesigner/MesoCrystalView.cpp
+++ b/GUI/coregui/Views/SampleDesigner/MesoCrystalView.cpp
@@ -21,9 +21,9 @@
MesoCrystalView::MesoCrystalView(QGraphicsItem* parent) : ConnectableView(parent)
{
- setName(Constants::MesoCrystalType);
+ setName("MesoCrystal");
setColor(DesignerHelper::getDefaultParticleColor());
- setRectangle(DesignerHelper::getDefaultBoundingRect(Constants::ParticleCoreShellType));
+ setRectangle(DesignerHelper::getDefaultBoundingRect("ParticleCoreShell"));
addPort("out", NodeEditorPort::OUTPUT, NodeEditorPort::FORM_FACTOR)
->setToolTip(QStringLiteral("Connect to the ParticleLayout"));
addPort("basis", NodeEditorPort::INPUT, NodeEditorPort::FORM_FACTOR)
diff --git a/GUI/coregui/Views/SampleDesigner/MultiLayerView.cpp b/GUI/coregui/Views/SampleDesigner/MultiLayerView.cpp
index 746e029063f0c7afcfc00fe32d1e5553f619b29b..1c3cbf6e34688e2eb92a80fb716c9bd47853d59c 100644
--- a/GUI/coregui/Views/SampleDesigner/MultiLayerView.cpp
+++ b/GUI/coregui/Views/SampleDesigner/MultiLayerView.cpp
@@ -27,7 +27,7 @@ MultiLayerView::MultiLayerView(QGraphicsItem* parent) : ILayerView(parent)
{
setColor(QColor(Qt::blue));
- setRectangle(DesignerHelper::getDefaultBoundingRect(Constants::MultiLayerType));
+ setRectangle(DesignerHelper::getDefaultBoundingRect("MultiLayer"));
setAcceptHoverEvents(false);
setAcceptDrops(true);
connect(this, SIGNAL(childrenChanged()), this, SLOT(updateHeight()));
diff --git a/GUI/coregui/Views/SampleDesigner/ParticleCompositionView.cpp b/GUI/coregui/Views/SampleDesigner/ParticleCompositionView.cpp
index 652c7765f57d88312bb3ac22e410c295ba35995c..952bf6acf9194f86f4a89940a9082fa2e4bd8983 100644
--- a/GUI/coregui/Views/SampleDesigner/ParticleCompositionView.cpp
+++ b/GUI/coregui/Views/SampleDesigner/ParticleCompositionView.cpp
@@ -20,9 +20,9 @@
ParticleCompositionView::ParticleCompositionView(QGraphicsItem* parent) : ConnectableView(parent)
{
- setName(Constants::ParticleCompositionType);
+ setName("ParticleComposition");
setColor(DesignerHelper::getDefaultParticleColor());
- setRectangle(DesignerHelper::getDefaultBoundingRect(Constants::ParticleCoreShellType));
+ setRectangle(DesignerHelper::getDefaultBoundingRect("ParticleCoreShell"));
addPort("out", NodeEditorPort::OUTPUT, NodeEditorPort::FORM_FACTOR)
->setToolTip(QStringLiteral("Connect to the ParticleLayout"));
addPort("particles", NodeEditorPort::INPUT, NodeEditorPort::FORM_FACTOR)
diff --git a/GUI/coregui/Views/SampleDesigner/ParticleCoreShellView.cpp b/GUI/coregui/Views/SampleDesigner/ParticleCoreShellView.cpp
index e33415ce178b05f591aa3bd001d5703ace8a3d7f..b7b996273b25fb1422ab75a8da195a0add3fe61e 100644
--- a/GUI/coregui/Views/SampleDesigner/ParticleCoreShellView.cpp
+++ b/GUI/coregui/Views/SampleDesigner/ParticleCoreShellView.cpp
@@ -20,9 +20,9 @@
ParticleCoreShellView::ParticleCoreShellView(QGraphicsItem* parent) : ConnectableView(parent)
{
- setName(Constants::ParticleCoreShellType);
+ setName("ParticleCoreShell");
setColor(DesignerHelper::getDefaultParticleColor());
- setRectangle(DesignerHelper::getDefaultBoundingRect(Constants::ParticleCoreShellType));
+ setRectangle(DesignerHelper::getDefaultBoundingRect("ParticleCoreShell"));
addPort("out", NodeEditorPort::OUTPUT, NodeEditorPort::FORM_FACTOR)
->setToolTip(QStringLiteral("Connect to the ParticleLayout"));
addPort("core", NodeEditorPort::INPUT, NodeEditorPort::FORM_FACTOR)
diff --git a/GUI/coregui/Views/SampleDesigner/ParticleDistributionView.cpp b/GUI/coregui/Views/SampleDesigner/ParticleDistributionView.cpp
index d2b188c45a26175725748c6496c11f1a530a4396..cc3af4b669679dbc83e589333bcb94b2b8854289 100644
--- a/GUI/coregui/Views/SampleDesigner/ParticleDistributionView.cpp
+++ b/GUI/coregui/Views/SampleDesigner/ParticleDistributionView.cpp
@@ -19,9 +19,9 @@
ParticleDistributionView::ParticleDistributionView(QGraphicsItem* parent) : ConnectableView(parent)
{
- setName(Constants::ParticleDistributionType);
+ setName("ParticleDistribution");
setColor(DesignerHelper::getDefaultParticleColor());
- setRectangle(DesignerHelper::getDefaultBoundingRect(Constants::ParticleDistributionType));
+ setRectangle(DesignerHelper::getDefaultBoundingRect("ParticleDistribution"));
addPort("out", NodeEditorPort::OUTPUT, NodeEditorPort::FORM_FACTOR)
->setToolTip(QStringLiteral("Connect to the ParticleLayout"));
addPort("particle", NodeEditorPort::INPUT, NodeEditorPort::FORM_FACTOR)
diff --git a/GUI/coregui/Views/SampleDesigner/ParticleLayoutView.cpp b/GUI/coregui/Views/SampleDesigner/ParticleLayoutView.cpp
index 30a641b4fd67938523a31cde76d4a69dcfe924a8..2232878faf4ac366e1783637163ef460376f1d4c 100644
--- a/GUI/coregui/Views/SampleDesigner/ParticleLayoutView.cpp
+++ b/GUI/coregui/Views/SampleDesigner/ParticleLayoutView.cpp
@@ -20,7 +20,7 @@
ParticleLayoutView::ParticleLayoutView(QGraphicsItem* parent) : ConnectableView(parent)
{
- setName(Constants::ParticleLayoutType);
+ setName("ParticleLayout");
setColor(QColor(135, 206, 50));
setRectangle(DesignerHelper::getParticleLayoutBoundingRect());
addPort("out", NodeEditorPort::OUTPUT, NodeEditorPort::PARTICLE_LAYOUT)
diff --git a/GUI/coregui/Views/SampleDesigner/ParticleView.cpp b/GUI/coregui/Views/SampleDesigner/ParticleView.cpp
index ac3eebe7e128c5d2b38f922380202814ab8521c1..e77b2fdc4be78e1c4bf44e71ce1b32f10becf79f 100644
--- a/GUI/coregui/Views/SampleDesigner/ParticleView.cpp
+++ b/GUI/coregui/Views/SampleDesigner/ParticleView.cpp
@@ -25,7 +25,7 @@
ParticleView::ParticleView(QGraphicsItem* parent) : ConnectableView(parent)
{
- setName(Constants::ParticleType);
+ setName("Particle");
setColor(DesignerHelper::getDefaultParticleColor());
setRectangle(DesignerHelper::getParticleBoundingRect());
addPort("out", NodeEditorPort::OUTPUT, NodeEditorPort::FORM_FACTOR)
diff --git a/GUI/coregui/Views/SampleDesigner/SampleViewAligner.cpp b/GUI/coregui/Views/SampleDesigner/SampleViewAligner.cpp
index c4f1b5f7d5a30a8144ae62011ff689eadc7cab11..8d4e5199c6a4cf27b216e9b83e0bf84120ba00b3 100644
--- a/GUI/coregui/Views/SampleDesigner/SampleViewAligner.cpp
+++ b/GUI/coregui/Views/SampleDesigner/SampleViewAligner.cpp
@@ -123,14 +123,14 @@ QList<IView*> SampleViewAligner::getConnectedViews(IView* view)
QList<SessionItem*> connected_items;
- if (itemOfView->parent()->modelType() == Constants::LayerType) {
+ if (itemOfView->parent()->modelType() == "Layer") {
// e.g. we are dealing here with ParticleLayout, so we will use directly MultiLayer to
// interact with
connected_items.append(itemOfView->parent()->parent());
} else {
connected_items.append(itemOfView->parent());
}
- if (itemOfView->modelType() == Constants::MultiLayerType) {
+ if (itemOfView->modelType() == "MultiLayer") {
// MultiLayer will not interact with its Layers, but with they children, e.g. with
// ParticleLayouts
for (auto child : itemOfView->children()) {
diff --git a/GUI/coregui/Views/SampleDesigner/SampleViewFactory.cpp b/GUI/coregui/Views/SampleDesigner/SampleViewFactory.cpp
index b43635870cbec4a1ded6cacbe60804dbcf77e34a..fae691469d19f321fd14ddb4f39ce65134a6abfc 100644
--- a/GUI/coregui/Views/SampleDesigner/SampleViewFactory.cpp
+++ b/GUI/coregui/Views/SampleDesigner/SampleViewFactory.cpp
@@ -13,7 +13,6 @@
// ************************************************************************** //
#include "GUI/coregui/Views/SampleDesigner/SampleViewFactory.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/SampleDesigner/InterferenceFunctionViews.h"
#include "GUI/coregui/Views/SampleDesigner/LayerView.h"
#include "GUI/coregui/Views/SampleDesigner/MesoCrystalView.h"
@@ -26,21 +25,21 @@
#include "GUI/coregui/Views/SampleDesigner/TransformationView.h"
QStringList SampleViewFactory::m_valid_item_names =
- QStringList() << Constants::MultiLayerType << Constants::LayerType
- << Constants::ParticleLayoutType << Constants::ParticleType
- << Constants::RotationType << Constants::ParticleCoreShellType
- << Constants::ParticleCompositionType << Constants::MesoCrystalType
- << Constants::ParticleDistributionType
- << Constants::InterferenceFunction1DLatticeType
- << Constants::InterferenceFunction2DLatticeType
- << Constants::InterferenceFunction2DParaCrystalType
- << Constants::InterferenceFunctionFinite2DLatticeType
- << Constants::InterferenceFunctionHardDiskType
- << Constants::InterferenceFunctionRadialParaCrystalType;
+ QStringList() << "MultiLayer" << "Layer"
+ << "ParticleLayout" << "Particle"
+ << "Rotation" << "ParticleCoreShell"
+ << "ParticleComposition" << "MesoCrystal"
+ << "ParticleDistribution"
+ << "Interference1DLattice"
+ << "Interference2DLattice"
+ << "Interference2DParaCrystal"
+ << "InterferenceFinite2DLattice"
+ << "InterferenceHardDisk"
+ << "InterferenceRadialParaCrystal";
bool SampleViewFactory::isValidType(const QString& name)
{
- if (name.startsWith(Constants::FormFactorType)) {
+ if (name.startsWith("FormFactor")) {
return true;
} else {
return m_valid_item_names.contains(name);
@@ -49,35 +48,35 @@ bool SampleViewFactory::isValidType(const QString& name)
IView* SampleViewFactory::createSampleView(const QString& name)
{
- if (name == Constants::MultiLayerType) {
+ if (name == "MultiLayer") {
return new MultiLayerView();
- } else if (name == Constants::LayerType) {
+ } else if (name == "Layer") {
return new LayerView();
- } else if (name == Constants::ParticleLayoutType) {
+ } else if (name == "ParticleLayout") {
return new ParticleLayoutView();
- } else if (name == Constants::ParticleType) {
+ } else if (name == "Particle") {
return new ParticleView();
- } else if (name == Constants::RotationType) {
+ } else if (name == "Rotation") {
return new TransformationView();
- } else if (name == Constants::ParticleCoreShellType) {
+ } else if (name == "ParticleCoreShell") {
return new ParticleCoreShellView();
- } else if (name == Constants::ParticleCompositionType) {
+ } else if (name == "ParticleComposition") {
return new ParticleCompositionView();
- } else if (name == Constants::MesoCrystalType) {
+ } else if (name == "MesoCrystal") {
return new MesoCrystalView();
- } else if (name == Constants::ParticleDistributionType) {
+ } else if (name == "ParticleDistribution") {
return new ParticleDistributionView();
- } else if (name == Constants::InterferenceFunction1DLatticeType) {
+ } else if (name == "Interference1DLattice") {
return new InterferenceFunction1DLatticeView();
- } else if (name == Constants::InterferenceFunction2DLatticeType) {
+ } else if (name == "Interference2DLattice") {
return new InterferenceFunction2DLatticeView();
- } else if (name == Constants::InterferenceFunction2DParaCrystalType) {
+ } else if (name == "Interference2DParaCrystal") {
return new InterferenceFunction2DParaCrystalView();
- } else if (name == Constants::InterferenceFunctionFinite2DLatticeType) {
+ } else if (name == "InterferenceFinite2DLattice") {
return new InterferenceFunctionFinite2DLatticeView();
- } else if (name == Constants::InterferenceFunctionHardDiskType) {
+ } else if (name == "InterferenceHardDisk") {
return new InterferenceFunctionHardDiskView();
- } else if (name == Constants::InterferenceFunctionRadialParaCrystalType) {
+ } else if (name == "InterferenceRadialParaCrystal") {
return new InterferenceFunctionRadialParaCrystalView();
}
return 0;
diff --git a/GUI/coregui/Views/SampleDesigner/TransformationView.cpp b/GUI/coregui/Views/SampleDesigner/TransformationView.cpp
index ed51ab8fbab08133f4bbcfd396f7f346b68e33bf..4f1484df715039de8b4a08780b23a819bf01280f 100644
--- a/GUI/coregui/Views/SampleDesigner/TransformationView.cpp
+++ b/GUI/coregui/Views/SampleDesigner/TransformationView.cpp
@@ -13,12 +13,11 @@
// ************************************************************************** //
#include "GUI/coregui/Views/SampleDesigner/TransformationView.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/SampleDesigner/DesignerHelper.h"
TransformationView::TransformationView(QGraphicsItem* parent) : ConnectableView(parent)
{
- setName(Constants::RotationType);
+ setName("Rotation");
setColor(DesignerHelper::getDefaultTransformationColor());
setRectangle(DesignerHelper::getTransformationBoundingRect());
addPort("out", NodeEditorPort::OUTPUT, NodeEditorPort::TRANSFORMATION)
diff --git a/GUI/coregui/Views/SimulationWidgets/SimulationDataSelectorWidget.cpp b/GUI/coregui/Views/SimulationWidgets/SimulationDataSelectorWidget.cpp
index 524e2bec05b6cc99b20e0fe06efb17c9dfd79d25..ad57d695c174acee6cfd09596158abbaa27ffae5 100644
--- a/GUI/coregui/Views/SimulationWidgets/SimulationDataSelectorWidget.cpp
+++ b/GUI/coregui/Views/SimulationWidgets/SimulationDataSelectorWidget.cpp
@@ -122,7 +122,7 @@ void SimulationDataSelectorWidget::updateViewElements()
updateSelection(m_instrumentCombo,
ModelUtils::topItemNames(m_applicationModels->instrumentModel()));
updateSelection(m_sampleCombo, ModelUtils::topItemNames(m_applicationModels->sampleModel(),
- Constants::MultiLayerType));
+ "MultiLayer"));
updateSelection(m_realDataCombo, ModelUtils::topItemNames(m_applicationModels->realDataModel()),
true);
}
diff --git a/GUI/coregui/Views/SpecularDataWidgets/SpecularPlot.cpp b/GUI/coregui/Views/SpecularDataWidgets/SpecularPlot.cpp
index 5e3a930632886003bc001e337cb3c33322a6cb27..eeabf2b832b3117029d9081965197c67a8bfb22d 100644
--- a/GUI/coregui/Views/SpecularDataWidgets/SpecularPlot.cpp
+++ b/GUI/coregui/Views/SpecularDataWidgets/SpecularPlot.cpp
@@ -110,8 +110,8 @@ void SpecularPlot::subscribeToItem()
specularItem()->mapper()->setOnChildPropertyChange(
[this](SessionItem* item, const QString name) {
- if (item->modelType() == Constants::BasicAxisType
- || item->modelType() == Constants::AmplitudeAxisType)
+ if (item->modelType() == "BasicAxis"
+ || item->modelType() == "AmplitudeAxis")
modifyAxesProperties(item->itemName(), name);
},
this);
diff --git a/GUI/coregui/Views/TestView.cpp b/GUI/coregui/Views/TestView.cpp
index c824faffe9f13538b1d3b183d0ffc8de4dab1389..125315ad1e9fe98ce6b2c3174bfb40db2d30dc86 100644
--- a/GUI/coregui/Views/TestView.cpp
+++ b/GUI/coregui/Views/TestView.cpp
@@ -87,7 +87,7 @@ void TestView::test_MinimizerSettings()
SessionModel* model = new SessionModel("TempModel", this);
MinimizerContainerItem* minimizerItem = dynamic_cast<MinimizerContainerItem*>(
- model->insertNewItem(Constants::MinimizerContainerType));
+ model->insertNewItem("MinimizerContainer"));
widget->setItem(minimizerItem);
}
@@ -182,7 +182,7 @@ void TestView::test_specular_data_widget()
SessionModel* tempModel = new SessionModel("Test", this);
// creating job item
- auto job_item = dynamic_cast<JobItem*>(tempModel->insertNewItem(Constants::JobItemType));
+ auto job_item = dynamic_cast<JobItem*>(tempModel->insertNewItem("JobItem"));
// creating "simulation" data
auto data_item = new SpecularDataItem();
diff --git a/GUI/coregui/mainwindow/OutputDataIOService.cpp b/GUI/coregui/mainwindow/OutputDataIOService.cpp
index a5ae64fdbc723cf8a71b6487517abc843fa9c7dc..28858fdba1e50716523947843b60dd1c9d8bdbba 100644
--- a/GUI/coregui/mainwindow/OutputDataIOService.cpp
+++ b/GUI/coregui/mainwindow/OutputDataIOService.cpp
@@ -17,7 +17,6 @@
#include "GUI/coregui/Models/ApplicationModels.h"
#include "GUI/coregui/Models/JobItem.h"
#include "GUI/coregui/Models/ModelPath.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/mainwindow/ProjectUtils.h"
#include "GUI/coregui/mainwindow/SaveLoadInterface.h"
#include "GUI/coregui/utils/MessageService.h"
@@ -79,7 +78,7 @@ void OutputDataIOService::load(const QString& projectDir, MessageService* messag
if (auto jobItem = parentJobItem(item)) {
if (jobItem->isRunning()) {
jobItem->setComments(QString("Possible GUI crash while job was running"));
- jobItem->setStatus(Constants::STATUS_FAILED);
+ jobItem->setStatus("Failed");
}
}
@@ -88,7 +87,7 @@ void OutputDataIOService::load(const QString& projectDir, MessageService* messag
// Handling corrupted file on disk
jobItem->setComments(
QString("Load of the data from disk failed with '%1'").arg(QString(ex.what())));
- jobItem->setStatus(Constants::STATUS_FAILED);
+ jobItem->setStatus("Failed");
}
if (messageService)
messageService->send_warning(this, QString(ex.what()));
@@ -131,7 +130,7 @@ JobItem* parentJobItem(SaveLoadInterface* item)
{
auto session_item = dynamic_cast<SessionItem*>(item); // sidecast
auto jobItem =
- dynamic_cast<const JobItem*>(ModelPath::ancestor(session_item, Constants::JobItemType));
+ dynamic_cast<const JobItem*>(ModelPath::ancestor(session_item, "JobItem"));
return const_cast<JobItem*>(jobItem);
}
} // namespace
diff --git a/GUI/coregui/mainwindow/tooltipdatabase.cpp b/GUI/coregui/mainwindow/tooltipdatabase.cpp
index a3bf9573e64df3a64d1a12a2f7e3abe75dbe1ab6..d9633af52d4150e3ea7949460bae7e3014b882cb 100644
--- a/GUI/coregui/mainwindow/tooltipdatabase.cpp
+++ b/GUI/coregui/mainwindow/tooltipdatabase.cpp
@@ -13,7 +13,6 @@
// ************************************************************************** //
#include "GUI/coregui/mainwindow/tooltipdatabase.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/utils/GUIHelpers.h"
#include <QFile>
#include <QXmlStreamReader>
@@ -52,7 +51,7 @@ QString ToolTipDataBase::widgetboxToolTip(const QString& className)
{
Q_ASSERT(m_instance);
QString modelName(className);
- modelName.remove(Constants::FormFactorType);
+ modelName.remove("FormFactor");
return m_instance->this_getToolTip(sampleViewContext, modelName, titleProperty);
}
diff --git a/Tests/Functional/GUI/GUISpecial/GUITranslationTest.cpp b/Tests/Functional/GUI/GUISpecial/GUITranslationTest.cpp
index f95037c6bbc39e0b56529203236eb84c5be5efd3..977178369680246ef189e057c273056f266af9ba 100644
--- a/Tests/Functional/GUI/GUISpecial/GUITranslationTest.cpp
+++ b/Tests/Functional/GUI/GUISpecial/GUITranslationTest.cpp
@@ -252,15 +252,15 @@ namespace
const QVector<QPair<QStringList, QStringList>> black_list{
{// Global scope
{QString()},
- {Constants::DistributionSigmaFactor, Constants::MaterialRefractiveDataType,
- Constants::MaterialSLDDataType, MaterialItem::P_MAGNETIZATION}},
+ {"Sigma factor", "MaterialRefractiveData",
+ "MaterialSLDData", MaterialItem::P_MAGNETIZATION}},
{// Instrument scope
- {Constants::GISASInstrumentType, Constants::OffSpecInstrumentType,
- Constants::SpecularInstrumentType},
+ {"GISASInstrument", "OffSpecInstrument",
+ "SpecularInstrument"},
{// Distribution types
- Constants::DistributionGateType, Constants::DistributionLorentzType,
- Constants::DistributionGaussianType, Constants::DistributionLogNormalType,
- Constants::DistributionCosineType, Constants::DistributionTrapezoidType,
+ "DistributionGate", "DistributionLorentz",
+ "DistributionGaussian", "DistributionLogNormal",
+ "DistributionCosine", "DistributionTrapezoid",
// Detector axes
SphericalDetectorItem::P_PHI_AXIS, SphericalDetectorItem::P_ALPHA_AXIS,
@@ -274,7 +274,7 @@ const QVector<QPair<QStringList, QStringList>> black_list{
RectangularDetectorItem::P_DBEAM_V0, RectangularDetectorItem::P_DISTANCE,
// Detector resolution
- Constants::ResolutionFunction2DGaussianType,
+ "ResolutionFunction2DGaussian",
// Beam angle parameters
BeamItem::P_INCLINATION_ANGLE, BeamItem::P_AZIMUTHAL_ANGLE}}};
diff --git a/Tests/UnitTests/GUI/TestComponentProxyModel.cpp b/Tests/UnitTests/GUI/TestComponentProxyModel.cpp
index 527ff6a2db4d1ecb68db54d3e7435e80626b864d..c65f5d886d0934be8fa4c749b9cd0fbdf336a923 100644
--- a/Tests/UnitTests/GUI/TestComponentProxyModel.cpp
+++ b/Tests/UnitTests/GUI/TestComponentProxyModel.cpp
@@ -8,7 +8,6 @@
#include "GUI/coregui/Models/ProxyModelStrategy.h"
#include "GUI/coregui/Models/SessionModel.h"
#include "GUI/coregui/Models/VectorItem.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "Tests/UnitTests/GUI/test_utils.h"
#include "Tests/UnitTests/utilities/google_test.h"
#include <QDebug>
@@ -49,7 +48,7 @@ TEST_F(TestComponentProxyModel, test_setModel)
TEST_F(TestComponentProxyModel, test_setModelWithItem)
{
SessionModel model("TestModel");
- model.insertNewItem(Constants::PropertyType);
+ model.insertNewItem("Property");
ComponentProxyModel proxy;
proxy.setSessionModel(&model);
@@ -67,7 +66,7 @@ TEST_F(TestComponentProxyModel, test_setModelWithVector)
const int ncols = static_cast<int>(SessionFlags::MAX_COLUMNS);
SessionModel model("TestModel");
- SessionItem* item = model.insertNewItem(Constants::VectorType);
+ SessionItem* item = model.insertNewItem("Vector");
item->setItemValue(VectorItem::P_X, 1.0);
item->setItemValue(VectorItem::P_Y, 2.0);
item->setItemValue(VectorItem::P_Z, 3.0);
@@ -158,9 +157,9 @@ TEST_F(TestComponentProxyModel, test_setModelWithVector)
TEST_F(TestComponentProxyModel, test_displayRole)
{
SessionModel model("TestModel");
- SessionItem* item1 = model.insertNewItem(Constants::PropertyType);
+ SessionItem* item1 = model.insertNewItem("Property");
item1->setValue(1.0);
- SessionItem* item2 = model.insertNewItem(Constants::PropertyType);
+ SessionItem* item2 = model.insertNewItem("Property");
item2->setValue(2.0);
EXPECT_EQ(model.data(model.index(0, 1, QModelIndex()), Qt::DisplayRole).toDouble(), 1.0);
@@ -178,7 +177,7 @@ TEST_F(TestComponentProxyModel, test_displayRole)
TEST_F(TestComponentProxyModel, test_setData)
{
SessionModel model("TestModel");
- SessionItem* item = model.insertNewItem(Constants::PropertyType);
+ SessionItem* item = model.insertNewItem("Property");
item->setValue(1.0);
ComponentProxyModel proxy;
@@ -229,7 +228,7 @@ TEST_F(TestComponentProxyModel, test_insertRows)
QSignalSpy spyProxy(&proxy, &ComponentProxyModel::layoutChanged);
// inserting item in the source
- model.insertNewItem(Constants::PropertyType);
+ model.insertNewItem("Property");
EXPECT_EQ(spyProxy.count(), 1);
EXPECT_EQ(proxy.rowCount(QModelIndex()), 1);
}
@@ -246,11 +245,11 @@ TEST_F(TestComponentProxyModel, test_componentStrategy)
proxy.setSessionModel(&model);
// inserting particle
- SessionItem* item = model.insertNewItem(Constants::ParticleType);
+ SessionItem* item = model.insertNewItem("Particle");
auto group = dynamic_cast<GroupItem*>(item->getItem(ParticleItem::P_FORM_FACTOR));
SessionItem* ffItem = item->getGroupItem(ParticleItem::P_FORM_FACTOR);
EXPECT_TRUE(ffItem->parent() == group);
- EXPECT_TRUE(ffItem->modelType() == Constants::CylinderType);
+ EXPECT_TRUE(ffItem->modelType() == "Cylinder");
// original indices
QModelIndex particleIndex = model.indexOfItem(item);
@@ -291,21 +290,21 @@ TEST_F(TestComponentProxyModel, test_componentStrategyFormFactorChanges)
proxy.setSessionModel(&model);
// inserting particle
- SessionItem* item = model.insertNewItem(Constants::ParticleType);
+ SessionItem* item = model.insertNewItem("Particle");
auto group = dynamic_cast<GroupItem*>(item->getItem(ParticleItem::P_FORM_FACTOR));
SessionItem* ffItem = item->getGroupItem(ParticleItem::P_FORM_FACTOR);
EXPECT_TRUE(ffItem->parent() == group);
- EXPECT_TRUE(ffItem->modelType() == Constants::CylinderType);
+ EXPECT_TRUE(ffItem->modelType() == "Cylinder");
// changing form factor type
- group->setCurrentType(Constants::FullSphereType);
+ group->setCurrentType("FullSphere");
QModelIndex groupProxyIndex = proxy.mapFromSource(model.indexOfItem(group));
EXPECT_EQ(proxy.rowCount(groupProxyIndex), 1); // sphere radius
EXPECT_EQ(proxy.columnCount(groupProxyIndex), 2);
// changing back to Cylinder
- group->setCurrentType(Constants::CylinderType);
+ group->setCurrentType("Cylinder");
groupProxyIndex = proxy.mapFromSource(model.indexOfItem(group));
EXPECT_EQ(proxy.rowCount(groupProxyIndex), 2); // cylinder radius, length
EXPECT_EQ(proxy.columnCount(groupProxyIndex), 2);
@@ -324,7 +323,7 @@ TEST_F(TestComponentProxyModel, test_setRootPropertyItem)
proxy.setSessionModel(&model);
// inserting simple property item
- SessionItem* item = model.insertNewItem(Constants::PropertyType);
+ SessionItem* item = model.insertNewItem("Property");
item->setValue(42.0);
proxy.setRootIndex(model.indexOfItem(item));
@@ -361,10 +360,10 @@ TEST_F(TestComponentProxyModel, test_setRootIndexLayer)
proxy.setSessionModel(&model);
// inserting multilayer with two layers
- auto multilayer = model.insertNewItem(Constants::MultiLayerType);
- auto layer1 = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
- auto layout = model.insertNewItem(Constants::ParticleLayoutType, model.indexOfItem(layer1));
- model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
+ auto multilayer = model.insertNewItem("MultiLayer");
+ auto layer1 = model.insertNewItem("Layer", model.indexOfItem(multilayer));
+ auto layout = model.insertNewItem("ParticleLayout", model.indexOfItem(layer1));
+ model.insertNewItem("Layer", model.indexOfItem(multilayer));
proxy.setRootIndex(model.indexOfItem(layer1));
EXPECT_EQ(proxy.rowCount(QModelIndex()), 1);
diff --git a/Tests/UnitTests/GUI/TestComponentUtils.cpp b/Tests/UnitTests/GUI/TestComponentUtils.cpp
index 3b78d766abdae01079c73d3b44f46c24ae88714f..d4cff59eb0887ca89b3139ea55cd22f1819c7c09 100644
--- a/Tests/UnitTests/GUI/TestComponentUtils.cpp
+++ b/Tests/UnitTests/GUI/TestComponentUtils.cpp
@@ -2,7 +2,6 @@
#include "GUI/coregui/Models/ParticleItem.h"
#include "GUI/coregui/Models/SessionItem.h"
#include "GUI/coregui/Models/SessionModel.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/PropertyEditor/ComponentUtils.h"
#include "Tests/UnitTests/utilities/google_test.h"
#include <QDebug>
@@ -17,7 +16,7 @@ TEST_F(TestComponentUtils, test_componentItems)
{
SessionModel model("TestModel");
- SessionItem* particle = model.insertNewItem(Constants::ParticleType);
+ SessionItem* particle = model.insertNewItem("Particle");
SessionItem* group = particle->getItem(ParticleItem::P_FORM_FACTOR);
SessionItem* ffItem = particle->getGroupItem(ParticleItem::P_FORM_FACTOR);
@@ -37,10 +36,10 @@ TEST_F(TestComponentUtils, test_componentItemsFFChange)
{
SessionModel model("TestModel");
- SessionItem* particle = model.insertNewItem(Constants::ParticleType);
+ SessionItem* particle = model.insertNewItem("Particle");
SessionItem* group = particle->getItem(ParticleItem::P_FORM_FACTOR);
- particle->setGroupProperty(ParticleItem::P_FORM_FACTOR, Constants::FullSphereType);
+ particle->setGroupProperty(ParticleItem::P_FORM_FACTOR, "FullSphere");
SessionItem* sphereItem = particle->getGroupItem(ParticleItem::P_FORM_FACTOR);
QList<const SessionItem*> expectedList =
diff --git a/Tests/UnitTests/GUI/TestDataItemViews.cpp b/Tests/UnitTests/GUI/TestDataItemViews.cpp
index 38b69afa2f842da9dc8720394a52927196daef20..e55786999ca8ca4dd0ee173707dc6e8e04603f0a 100644
--- a/Tests/UnitTests/GUI/TestDataItemViews.cpp
+++ b/Tests/UnitTests/GUI/TestDataItemViews.cpp
@@ -19,7 +19,7 @@ public:
DataItem* TestDataItemViews::insertNewDataItem(SessionModel& model, double val)
{
- DataItem* item = dynamic_cast<DataItem*>(model.insertNewItem(Constants::SpecularDataType));
+ DataItem* item = dynamic_cast<DataItem*>(model.insertNewItem("SpecularData"));
auto data = TestUtils::createData(val, TestUtils::DIM::D1);
item->setOutputData(data.release());
return item;
@@ -29,7 +29,7 @@ TEST_F(TestDataItemViews, testDataLinking)
{
SessionModel model("TempModel");
auto view_item = dynamic_cast<DataPropertyContainer*>(
- model.insertNewItem(Constants::DataPropertyContainerType));
+ model.insertNewItem("DataPropertyContainer"));
DataItem* item = insertNewDataItem(model, 0.0);
view_item->addItem(item);
@@ -42,7 +42,7 @@ TEST_F(TestDataItemViews, testLinkingSeveralItems)
{
SessionModel model("TempModel");
auto view_item = dynamic_cast<DataPropertyContainer*>(
- model.insertNewItem(Constants::DataPropertyContainerType));
+ model.insertNewItem("DataPropertyContainer"));
DataItem* item = insertNewDataItem(model, 0.0);
DataItem* item2 = insertNewDataItem(model, 1.0);
DataItem* item3 = insertNewDataItem(model, 2.0);
@@ -61,7 +61,7 @@ TEST_F(TestDataItemViews, testColors)
{
SessionModel model("TempModel");
auto view_item = dynamic_cast<DataPropertyContainer*>(
- model.insertNewItem(Constants::DataPropertyContainerType));
+ model.insertNewItem("DataPropertyContainer"));
DataItem* item = insertNewDataItem(model, 0.0);
DataItem* item2 = insertNewDataItem(model, 1.0);
DataItem* item3 = insertNewDataItem(model, 2.0);
@@ -98,7 +98,7 @@ TEST_F(TestDataItemViews, testBrokenLink)
{
SessionModel model("TempModel");
auto view_item = dynamic_cast<DataPropertyContainer*>(
- model.insertNewItem(Constants::DataPropertyContainerType));
+ model.insertNewItem("DataPropertyContainer"));
DataItem* item = insertNewDataItem(model, 0.0);
view_item->addItem(item);
@@ -116,7 +116,7 @@ TEST_F(TestDataItemViews, testWrongHostingModel)
SessionModel model("TempModel");
DataItem* item = insertNewDataItem(model, 0.0);
auto view_item = dynamic_cast<DataPropertyContainer*>(
- model.insertNewItem(Constants::DataPropertyContainerType));
+ model.insertNewItem("DataPropertyContainer"));
view_item->addItem(item);
SessionModel model2("TempModel2");
@@ -141,7 +141,7 @@ TEST_F(TestDataItemViews, testSavingLinkedData)
DataItem* item = insertNewDataItem(*real_data_model, 0.0);
DataItem* item2 = insertNewDataItem(*real_data_model, 1.0);
auto view_item = dynamic_cast<DataPropertyContainer*>(
- real_data_model->insertNewItem(Constants::DataPropertyContainerType));
+ real_data_model->insertNewItem("DataPropertyContainer"));
view_item->addItem(item);
view_item->addItem(item2);
diff --git a/Tests/UnitTests/GUI/TestDataItems.cpp b/Tests/UnitTests/GUI/TestDataItems.cpp
index d5d4e793f58d1c4049e96a0057111fccb728a440..8bbf8576048ed8a6f3093c485e483fd252995635 100644
--- a/Tests/UnitTests/GUI/TestDataItems.cpp
+++ b/Tests/UnitTests/GUI/TestDataItems.cpp
@@ -36,10 +36,10 @@ void TestDataItems::testItemClock(QString model_type)
TEST_F(TestDataItems, testSpecularItemClock)
{
- testItemClock(Constants::SpecularDataType);
+ testItemClock("SpecularData");
}
TEST_F(TestDataItems, testIntensityItemClock)
{
- testItemClock(Constants::IntensityDataType);
+ testItemClock("IntensityData");
}
diff --git a/Tests/UnitTests/GUI/TestDetectorItems.cpp b/Tests/UnitTests/GUI/TestDetectorItems.cpp
index d3476c5c5a1a227aa57991d29192aa5dd21aa649..5be95f0424b2a09e80cb75f9a00047ea045fd49b 100644
--- a/Tests/UnitTests/GUI/TestDetectorItems.cpp
+++ b/Tests/UnitTests/GUI/TestDetectorItems.cpp
@@ -16,18 +16,18 @@ class TestDetectorItems : public ::testing::Test
TEST_F(TestDetectorItems, test_detectorAlignment)
{
InstrumentModel model;
- SessionItem* detector = model.insertNewItem(Constants::RectangularDetectorType);
+ SessionItem* detector = model.insertNewItem("RectangularDetector");
ComboProperty alignment =
detector->getItemValue(RectangularDetectorItem::P_ALIGNMENT).value<ComboProperty>();
// generic has some more items visible
- alignment.setValue(Constants::ALIGNMENT_GENERIC);
+ alignment.setValue("Generic");
detector->setItemValue(RectangularDetectorItem::P_ALIGNMENT,
QVariant::fromValue<ComboProperty>(alignment));
EXPECT_TRUE(detector->getItem(RectangularDetectorItem::P_NORMAL)->isVisible());
// should be disabled if we switch
- alignment.setValue(Constants::ALIGNMENT_TO_REFLECTED_BEAM);
+ alignment.setValue("Perpendicular to reflected beam");
detector->setItemValue(RectangularDetectorItem::P_ALIGNMENT,
QVariant::fromValue<ComboProperty>(alignment));
EXPECT_FALSE(detector->getItem(RectangularDetectorItem::P_NORMAL)->isVisible());
@@ -37,12 +37,12 @@ TEST_F(TestDetectorItems, test_resolutionFunction)
{
InstrumentModel model;
GISASInstrumentItem* instrument =
- dynamic_cast<GISASInstrumentItem*>(model.insertNewItem(Constants::GISASInstrumentType));
+ dynamic_cast<GISASInstrumentItem*>(model.insertNewItem("GISASInstrument"));
DetectorItem* detectorItem = instrument->detectorItem();
detectorItem->setGroupProperty(DetectorItem::P_RESOLUTION_FUNCTION,
- Constants::ResolutionFunction2DGaussianType);
+ "ResolutionFunction2DGaussian");
auto detector = detectorItem->createDetector();
auto convol =
diff --git a/Tests/UnitTests/GUI/TestFitParameterModel.cpp b/Tests/UnitTests/GUI/TestFitParameterModel.cpp
index f68fcec34806e230320d0d77519b26c4406d928f..ffd77987453966ba9a2351f4d256c958b850dc15 100644
--- a/Tests/UnitTests/GUI/TestFitParameterModel.cpp
+++ b/Tests/UnitTests/GUI/TestFitParameterModel.cpp
@@ -11,9 +11,9 @@ class TestFitParameterModel : public ::testing::Test
TEST_F(TestFitParameterModel, test_InitialState)
{
JobModel source;
- SessionItem* fitSuiteItem = source.insertNewItem(Constants::FitSuiteType);
+ SessionItem* fitSuiteItem = source.insertNewItem("FitSuite");
SessionItem* container =
- source.insertNewItem(Constants::FitParameterContainerType, fitSuiteItem->index(), -1,
+ source.insertNewItem("FitParameterContainer", fitSuiteItem->index(), -1,
FitSuiteItem::T_FIT_PARAMETERS);
FitParameterProxyModel proxy(dynamic_cast<FitParameterContainerItem*>(container));
@@ -26,14 +26,14 @@ TEST_F(TestFitParameterModel, test_InitialState)
TEST_F(TestFitParameterModel, test_addFitParameter)
{
JobModel source;
- SessionItem* fitSuiteItem = source.insertNewItem(Constants::FitSuiteType);
+ SessionItem* fitSuiteItem = source.insertNewItem("FitSuite");
SessionItem* container =
- source.insertNewItem(Constants::FitParameterContainerType, fitSuiteItem->index(), -1,
+ source.insertNewItem("FitParameterContainer", fitSuiteItem->index(), -1,
FitSuiteItem::T_FIT_PARAMETERS);
FitParameterProxyModel proxy(dynamic_cast<FitParameterContainerItem*>(container));
// adding fit parameter
- SessionItem* fitPar0 = source.insertNewItem(Constants::FitParameterType, container->index());
+ SessionItem* fitPar0 = source.insertNewItem("FitParameter", container->index());
fitPar0->setDisplayName(QStringLiteral("par"));
fitPar0->setItemValue(FitParameterItem::P_MIN, 1.0);
fitPar0->setItemValue(FitParameterItem::P_MAX, 2.0);
@@ -93,7 +93,7 @@ TEST_F(TestFitParameterModel, test_addFitParameter)
// ----------------------------------------------------
// adding second fit parameter
// ----------------------------------------------------
- SessionItem* fitPar1 = source.insertNewItem(Constants::FitParameterType, container->index());
+ SessionItem* fitPar1 = source.insertNewItem("FitParameter", container->index());
fitPar0->setDisplayName(QStringLiteral("par"));
fitPar0->setItemValue(FitParameterItem::P_MIN, 10.0);
fitPar0->setItemValue(FitParameterItem::P_MAX, 20.0);
@@ -131,21 +131,21 @@ TEST_F(TestFitParameterModel, test_addFitParameter)
TEST_F(TestFitParameterModel, test_addFitParameterAndLink)
{
JobModel source;
- SessionItem* fitSuiteItem = source.insertNewItem(Constants::FitSuiteType);
+ SessionItem* fitSuiteItem = source.insertNewItem("FitSuite");
SessionItem* container =
- source.insertNewItem(Constants::FitParameterContainerType, fitSuiteItem->index(), -1,
+ source.insertNewItem("FitParameterContainer", fitSuiteItem->index(), -1,
FitSuiteItem::T_FIT_PARAMETERS);
FitParameterProxyModel proxy(dynamic_cast<FitParameterContainerItem*>(container));
// adding fit parameter
- SessionItem* fitPar0 = source.insertNewItem(Constants::FitParameterType, container->index());
+ SessionItem* fitPar0 = source.insertNewItem("FitParameter", container->index());
fitPar0->setDisplayName(QStringLiteral("par"));
fitPar0->setItemValue(FitParameterItem::P_MIN, 1.0);
fitPar0->setItemValue(FitParameterItem::P_MAX, 2.0);
fitPar0->setItemValue(FitParameterItem::P_START_VALUE, 3.0);
// adding link
- SessionItem* link0 = source.insertNewItem(Constants::FitParameterLinkType, fitPar0->index());
+ SessionItem* link0 = source.insertNewItem("FitParameterLink", fitPar0->index());
link0->setItemValue(FitParameterLinkItem::P_LINK, "link0");
// checking index of root
@@ -175,7 +175,7 @@ TEST_F(TestFitParameterModel, test_addFitParameterAndLink)
EXPECT_EQ(linkIndex, proxy.indexOfItem(link0->getItem(FitParameterLinkItem::P_LINK)));
// adding second link
- SessionItem* link1 = source.insertNewItem(Constants::FitParameterLinkType, fitPar0->index());
+ SessionItem* link1 = source.insertNewItem("FitParameterLink", fitPar0->index());
link1->setItemValue(FitParameterLinkItem::P_LINK, "link1");
EXPECT_EQ(proxy.rowCount(index), 2);
EXPECT_EQ(proxy.columnCount(index), 1); // linkItem
@@ -195,19 +195,19 @@ TEST_F(TestFitParameterModel, test_addFitParameterAndLink)
TEST_F(TestFitParameterModel, test_addTwoFitParameterAndLinks)
{
JobModel source;
- SessionItem* fitSuiteItem = source.insertNewItem(Constants::FitSuiteType);
+ SessionItem* fitSuiteItem = source.insertNewItem("FitSuite");
SessionItem* container =
- source.insertNewItem(Constants::FitParameterContainerType, fitSuiteItem->index(), -1,
+ source.insertNewItem("FitParameterContainer", fitSuiteItem->index(), -1,
FitSuiteItem::T_FIT_PARAMETERS);
FitParameterProxyModel proxy(dynamic_cast<FitParameterContainerItem*>(container));
// adding fit parameters
- SessionItem* fitPar0 = source.insertNewItem(Constants::FitParameterType, container->index());
- SessionItem* link0 = source.insertNewItem(Constants::FitParameterLinkType, fitPar0->index());
+ SessionItem* fitPar0 = source.insertNewItem("FitParameter", container->index());
+ SessionItem* link0 = source.insertNewItem("FitParameterLink", fitPar0->index());
Q_UNUSED(link0);
- SessionItem* fitPar1 = source.insertNewItem(Constants::FitParameterType, container->index());
- SessionItem* link1 = source.insertNewItem(Constants::FitParameterLinkType, fitPar1->index());
+ SessionItem* fitPar1 = source.insertNewItem("FitParameter", container->index());
+ SessionItem* link1 = source.insertNewItem("FitParameterLink", fitPar1->index());
Q_UNUSED(link1);
// checking index of root
diff --git a/Tests/UnitTests/GUI/TestGroupItem.cpp b/Tests/UnitTests/GUI/TestGroupItem.cpp
index f9806b4690fffab35391d8fa40b30f3b264205b1..15a10d17f47b52f3a1b1b60dc2e12fb2b9ce9b12 100644
--- a/Tests/UnitTests/GUI/TestGroupItem.cpp
+++ b/Tests/UnitTests/GUI/TestGroupItem.cpp
@@ -54,10 +54,10 @@ TEST_F(TestGroupItem, test_CreateGroup)
{
SessionModel model("TestModel");
- GroupInfo groupInfo = SessionItemUtils::GetGroupInfo(Constants::FormFactorGroup);
- EXPECT_EQ(groupInfo.defaultType(), Constants::CylinderType);
+ GroupInfo groupInfo = SessionItemUtils::GetGroupInfo("Form Factor");
+ EXPECT_EQ(groupInfo.defaultType(), "Cylinder");
- auto groupItem = dynamic_cast<GroupItem*>(model.insertNewItem(Constants::GroupItemType));
+ auto groupItem = dynamic_cast<GroupItem*>(model.insertNewItem("GroupProperty"));
EXPECT_EQ(groupItem->children().size(), 0);
EXPECT_TRUE(groupItem->currentItem() == nullptr);
EXPECT_FALSE(groupItem->value().isValid());
@@ -72,7 +72,7 @@ TEST_F(TestGroupItem, test_CreateGroup)
EXPECT_EQ(groupItem->children().size(), 1);
EXPECT_EQ(groupItem->children()[0], groupItem->currentItem());
SessionItem* ffItem = groupItem->currentItem();
- EXPECT_EQ(ffItem->modelType(), Constants::CylinderType);
+ EXPECT_EQ(ffItem->modelType(), "Cylinder");
// checking current variant
QVariant value = groupItem->value();
@@ -84,20 +84,20 @@ TEST_F(TestGroupItem, test_CreateGroup)
EXPECT_EQ(combo.getValue(), groupInfo.itemLabels().at(index));
// changing current item
- SessionItem* newItem = groupItem->setCurrentType(Constants::FullSphereType);
+ SessionItem* newItem = groupItem->setCurrentType("FullSphere");
EXPECT_EQ(newItem, groupItem->currentItem());
- EXPECT_EQ(newItem->modelType(), Constants::FullSphereType);
+ EXPECT_EQ(newItem->modelType(), "FullSphere");
EXPECT_EQ(groupItem->children().size(), 2);
// checking current variant
combo = groupItem->value().value<ComboProperty>();
EXPECT_EQ(combo.getValues(), groupInfo.itemLabels());
- index = groupInfo.itemTypes().indexOf(Constants::FullSphereType);
+ index = groupInfo.itemTypes().indexOf("FullSphere");
EXPECT_EQ(combo.currentIndex(), index);
EXPECT_EQ(combo.getValue(), groupInfo.itemLabels().at(index));
// returning back to previous item
- EXPECT_EQ(groupItem->setCurrentType(Constants::CylinderType), ffItem);
+ EXPECT_EQ(groupItem->setCurrentType("Cylinder"), ffItem);
EXPECT_EQ(groupItem->currentItem(), ffItem);
EXPECT_EQ(groupItem->children().size(), 2);
}
@@ -106,13 +106,13 @@ TEST_F(TestGroupItem, test_CreateGroup)
TEST_F(TestGroupItem, test_groupPropertyWithDisplayNames)
{
- GroupInfo groupInfo = SessionItemUtils::GetGroupInfo(Constants::DistributionGroup);
+ GroupInfo groupInfo = SessionItemUtils::GetGroupInfo("Distribution group");
GroupItem groupItem;
groupItem.setGroupInfo(groupInfo);
SessionItem* cosineItem = groupItem.currentItem();
- cosineItem->setDisplayName(Constants::DistributionCosineType + QString::number(0));
+ cosineItem->setDisplayName("DistributionCosine" + QString::number(0));
EXPECT_EQ(groupItem.currentItem(), cosineItem);
}
diff --git a/Tests/UnitTests/GUI/TestLayerItems.cpp b/Tests/UnitTests/GUI/TestLayerItems.cpp
index bd0bc5a532f9d67e7363f5e588c3d1cc411cf2dc..0f6f581adcaa8de2da324faacddc49b9e5d83d9c 100644
--- a/Tests/UnitTests/GUI/TestLayerItems.cpp
+++ b/Tests/UnitTests/GUI/TestLayerItems.cpp
@@ -16,7 +16,7 @@ class TestLayerItems : public ::testing::Test
TEST_F(TestLayerItems, test_LayerDefaultMaterial)
{
ApplicationModels models;
- auto layer = models.sampleModel()->insertNewItem(Constants::LayerType);
+ auto layer = models.sampleModel()->insertNewItem("Layer");
auto materials = models.materialModel()->topItems();
auto defMaterial = materials.front();
diff --git a/Tests/UnitTests/GUI/TestLinkInstrument.cpp b/Tests/UnitTests/GUI/TestLinkInstrument.cpp
index ae39181a35b50d0823d2f37a4db267b3877b1a14..eafbeeab1682bdc3b81434c641264f6ecbc6f658 100644
--- a/Tests/UnitTests/GUI/TestLinkInstrument.cpp
+++ b/Tests/UnitTests/GUI/TestLinkInstrument.cpp
@@ -31,7 +31,7 @@ TEST_F(TestLinkInstrument, test_linkInstrumentManager)
// populating instrument model
GISASInstrumentItem* instrument = dynamic_cast<GISASInstrumentItem*>(
- instrumentModel.insertNewItem(Constants::GISASInstrumentType));
+ instrumentModel.insertNewItem("GISASInstrument"));
QString identifier = instrument->getItemValue(InstrumentItem::P_IDENTIFIER).toString();
// checking that LinkInstrumentManager was notified about new instrument
@@ -58,7 +58,7 @@ TEST_F(TestLinkInstrument, test_canLinkToInstrument)
// populating instrument model
GISASInstrumentItem* instrument = dynamic_cast<GISASInstrumentItem*>(
- instrumentModel.insertNewItem(Constants::GISASInstrumentType));
+ instrumentModel.insertNewItem("GISASInstrument"));
QString identifier = instrument->getItemValue(InstrumentItem::P_IDENTIFIER).toString();
// populating real data model, setting intensity data
@@ -72,7 +72,7 @@ TEST_F(TestLinkInstrument, test_canLinkToInstrument)
EXPECT_EQ(manager.linkedItems(instrument), QList<RealDataItem*>() << realData);
// changing detector type and checking that link remain
- instrument->setDetectorGroup(Constants::RectangularDetectorType);
+ instrument->setDetectorGroup("RectangularDetector");
EXPECT_EQ(manager.linkedItems(instrument), QList<RealDataItem*>() << realData);
// changing detector binning and checking that link is destroyed
diff --git a/Tests/UnitTests/GUI/TestMapperCases.cpp b/Tests/UnitTests/GUI/TestMapperCases.cpp
index f05279c3583bfcf2938153cc684464a9e0f77ed0..1f44ba02b8307f392fa37c75593847475b3cc028 100644
--- a/Tests/UnitTests/GUI/TestMapperCases.cpp
+++ b/Tests/UnitTests/GUI/TestMapperCases.cpp
@@ -17,20 +17,20 @@ class TestMapperCases : public ::testing::Test
TEST_F(TestMapperCases, test_ParticeleCompositionUpdate)
{
SampleModel model;
- SessionItem* multilayer = model.insertNewItem(Constants::MultiLayerType);
- SessionItem* layer = model.insertNewItem(Constants::LayerType, multilayer->index());
- SessionItem* layout = model.insertNewItem(Constants::ParticleLayoutType, layer->index());
+ SessionItem* multilayer = model.insertNewItem("MultiLayer");
+ SessionItem* layer = model.insertNewItem("Layer", multilayer->index());
+ SessionItem* layout = model.insertNewItem("ParticleLayout", layer->index());
// composition added to layout should have abundance enabled
SessionItem* compositionFree =
- model.insertNewItem(Constants::ParticleCompositionType, layout->index());
+ model.insertNewItem("ParticleComposition", layout->index());
EXPECT_TRUE(compositionFree->getItem(ParticleItem::P_ABUNDANCE)->isEnabled());
// composition added to distribution should have abundance disabled
SessionItem* distribution =
- model.insertNewItem(Constants::ParticleDistributionType, layout->index());
+ model.insertNewItem("ParticleDistribution", layout->index());
SessionItem* composition =
- model.insertNewItem(Constants::ParticleCompositionType, distribution->index());
+ model.insertNewItem("ParticleComposition", distribution->index());
EXPECT_TRUE(composition->getItem(ParticleItem::P_ABUNDANCE)->isEnabled() == false);
composition = distribution->takeRow(ParentRow(*composition));
@@ -41,16 +41,16 @@ TEST_F(TestMapperCases, test_ParticeleCompositionUpdate)
TEST_F(TestMapperCases, test_SimulationOptionsComputationToggle)
{
DocumentModel model;
- model.insertNewItem(Constants::SimulationOptionsType);
+ model.insertNewItem("SimulationOptions");
SimulationOptionsItem* item = model.simulationOptionsItem();
ComboProperty combo =
item->getItemValue(SimulationOptionsItem::P_COMPUTATION_METHOD).value<ComboProperty>();
- EXPECT_EQ(combo.getValue(), Constants::SIMULATION_ANALYTICAL);
+ EXPECT_EQ(combo.getValue(), "Analytical");
EXPECT_TRUE(item->getItem(SimulationOptionsItem::P_MC_POINTS)->isEnabled() == false);
- combo.setValue(Constants::SIMULATION_MONTECARLO);
+ combo.setValue("Monte-Carlo Integration");
item->setItemValue(SimulationOptionsItem::P_COMPUTATION_METHOD, combo.variant());
EXPECT_TRUE(item->getItem(SimulationOptionsItem::P_MC_POINTS)->isEnabled() == true);
}
diff --git a/Tests/UnitTests/GUI/TestMapperForItem.cpp b/Tests/UnitTests/GUI/TestMapperForItem.cpp
index 495741af6a348438c3cdafd152a0b10cf89813c4..300d65b7af214bf3129b051d63690898bb32efd4 100644
--- a/Tests/UnitTests/GUI/TestMapperForItem.cpp
+++ b/Tests/UnitTests/GUI/TestMapperForItem.cpp
@@ -3,7 +3,6 @@
#include "GUI/coregui/Models/SampleModel.h"
#include "GUI/coregui/Models/SessionItem.h"
#include "GUI/coregui/Models/SessionItemUtils.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "Tests/UnitTests/utilities/google_test.h"
#include <memory>
@@ -132,8 +131,8 @@ TEST_F(TestMapperForItem, test_onPropertyChange)
{
Widget w;
SampleModel model;
- SessionItem* multilayer = model.insertNewItem(Constants::MultiLayerType);
- SessionItem* layer = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
+ SessionItem* multilayer = model.insertNewItem("MultiLayer");
+ SessionItem* layer = model.insertNewItem("Layer", model.indexOfItem(multilayer));
// Mapper is looking on child; set property of child
setItem(layer, &w);
@@ -192,8 +191,8 @@ TEST_F(TestMapperForItem, test_onParentChange)
{
Widget w;
SampleModel model;
- SessionItem* multilayer = model.insertNewItem(Constants::MultiLayerType);
- SessionItem* layer = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
+ SessionItem* multilayer = model.insertNewItem("MultiLayer");
+ SessionItem* layer = model.insertNewItem("Layer", model.indexOfItem(multilayer));
// Mapper is looking on child; changing child's parent
setItem(layer, &w);
@@ -210,12 +209,12 @@ TEST_F(TestMapperForItem, test_onChildrenChange)
{
Widget w;
SampleModel model;
- SessionItem* multilayer = model.insertNewItem(Constants::MultiLayerType);
+ SessionItem* multilayer = model.insertNewItem("MultiLayer");
// Mapper is looking on parent; adding new child to parent
setItem(multilayer, &w);
EXPECT_TRUE(m_mapped_item == multilayer);
- model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
+ model.insertNewItem("Layer", model.indexOfItem(multilayer));
EXPECT_EQ(w.m_onPropertyChangeCount, 0);
EXPECT_EQ(w.m_onChildPropertyChangeCount, 2);
@@ -230,13 +229,13 @@ TEST_F(TestMapperForItem, test_onSiblingsChange)
{
Widget w;
SampleModel model;
- SessionItem* multilayer = model.insertNewItem(Constants::MultiLayerType);
- SessionItem* layer = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
+ SessionItem* multilayer = model.insertNewItem("MultiLayer");
+ SessionItem* layer = model.insertNewItem("Layer", model.indexOfItem(multilayer));
// Mapper is looking on child; adding another child to parent
setItem(layer, &w);
EXPECT_TRUE(m_mapped_item == layer);
- SessionItem* layer2 = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
+ SessionItem* layer2 = model.insertNewItem("Layer", model.indexOfItem(multilayer));
Q_UNUSED(layer2);
EXPECT_EQ(w.m_onPropertyChangeCount, 0);
@@ -255,8 +254,8 @@ TEST_F(TestMapperForItem, test_Subscription)
{
Widget w;
SampleModel model;
- SessionItem* multilayer = model.insertNewItem(Constants::MultiLayerType);
- SessionItem* layer = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
+ SessionItem* multilayer = model.insertNewItem("MultiLayer");
+ SessionItem* layer = model.insertNewItem("Layer", model.indexOfItem(multilayer));
// Mapper is looking on child; set property of child
setItem(layer, &w, true);
@@ -284,8 +283,8 @@ TEST_F(TestMapperForItem, test_TwoWidgetsSubscription)
{
Widget w1, w2;
SampleModel model;
- SessionItem* multilayer = model.insertNewItem(Constants::MultiLayerType);
- SessionItem* layer = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
+ SessionItem* multilayer = model.insertNewItem("MultiLayer");
+ SessionItem* layer = model.insertNewItem("Layer", model.indexOfItem(multilayer));
// Mapper is looking on child; set property of child
setItem(layer);
@@ -308,9 +307,9 @@ TEST_F(TestMapperForItem, test_AboutToRemoveChild)
{
Widget w;
SampleModel model;
- SessionItem* container = model.insertNewItem(Constants::ProjectionContainerType);
+ SessionItem* container = model.insertNewItem("ProjectionContainer");
- SessionItem* line = model.insertNewItem(Constants::HorizontalLineMaskType, container->index());
+ SessionItem* line = model.insertNewItem("HorizontalLineMask", container->index());
setItem(container, &w);
EXPECT_EQ(w.m_onAboutToRemoveChild, 0);
diff --git a/Tests/UnitTests/GUI/TestMaterialPropertyController.cpp b/Tests/UnitTests/GUI/TestMaterialPropertyController.cpp
index e8bfcf6ee8240ad9ea4b37d857e234c7546e595a..f3a274663b4c26e44bce448f5420c666e06eaeca 100644
--- a/Tests/UnitTests/GUI/TestMaterialPropertyController.cpp
+++ b/Tests/UnitTests/GUI/TestMaterialPropertyController.cpp
@@ -19,7 +19,7 @@ class TestMaterialPropertyController : public ::testing::Test
// materialModel.addRefractiveMaterial("name2", 3.0, 4.0);
// SampleModel sampleModel;
-// auto layer = sampleModel.insertNewItem(Constants::LayerType);
+// auto layer = sampleModel.insertNewItem("Layer");
// int property_changed(0);
// layer->mapper()->setOnPropertyChange(
@@ -69,9 +69,9 @@ TEST_F(TestMaterialPropertyController, test_ControllerInEditorContext)
auto mat3 = materialModel.addRefractiveMaterial("name3", 1.0, 2.0);
SampleModel sampleModel;
- auto layer1 = sampleModel.insertNewItem(Constants::LayerType);
- auto layer2 = sampleModel.insertNewItem(Constants::LayerType);
- auto layer3 = sampleModel.insertNewItem(Constants::LayerType);
+ auto layer1 = sampleModel.insertNewItem("Layer");
+ auto layer2 = sampleModel.insertNewItem("Layer");
+ auto layer3 = sampleModel.insertNewItem("Layer");
MaterialPropertyController controller;
controller.setModels(&materialModel, &sampleModel);
diff --git a/Tests/UnitTests/GUI/TestMessageService.cpp b/Tests/UnitTests/GUI/TestMessageService.cpp
index 90c458adf8abd5c04d7e3ad2a34fc25a0bd47c2f..0514ab7ffb7da6bbbfab82bc8076c844dd76cca0 100644
--- a/Tests/UnitTests/GUI/TestMessageService.cpp
+++ b/Tests/UnitTests/GUI/TestMessageService.cpp
@@ -1,4 +1,3 @@
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/utils/GUIHelpers.h"
#include "GUI/coregui/utils/GUIMessage.h"
#include "GUI/coregui/utils/MessageService.h"
diff --git a/Tests/UnitTests/GUI/TestModelUtils.cpp b/Tests/UnitTests/GUI/TestModelUtils.cpp
index 5220d75d0811e22c9967d91e560fad96005746af..0478f76b5fbf2fc771e31fcd2da18eba763292c9 100644
--- a/Tests/UnitTests/GUI/TestModelUtils.cpp
+++ b/Tests/UnitTests/GUI/TestModelUtils.cpp
@@ -2,7 +2,6 @@
#include "GUI/coregui/Models/ModelUtils.h"
#include "GUI/coregui/Models/SessionModel.h"
#include "GUI/coregui/Models/VectorItem.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "Tests/UnitTests/utilities/google_test.h"
#include <QVector>
@@ -33,19 +32,19 @@ TEST_F(TestModelUtils, test_topItemNames)
EXPECT_TRUE(ModelUtils::topItemNames(&model).isEmpty());
// inserting three top items
- auto item = model.insertNewItem(Constants::MultiLayerType);
+ auto item = model.insertNewItem("MultiLayer");
item->setItemName("name1");
- item = model.insertNewItem(Constants::LayerType);
- item = model.insertNewItem(Constants::MultiLayerType);
+ item = model.insertNewItem("Layer");
+ item = model.insertNewItem("MultiLayer");
item->setItemName("name2");
// checking names of items of certain type
- ASSERT_EQ(ModelUtils::topItemNames(&model, Constants::MultiLayerType).size(), 2);
- EXPECT_EQ(ModelUtils::topItemNames(&model, Constants::MultiLayerType).at(0), QString("name1"));
- EXPECT_EQ(ModelUtils::topItemNames(&model, Constants::MultiLayerType).at(1), QString("name2"));
+ ASSERT_EQ(ModelUtils::topItemNames(&model, "MultiLayer").size(), 2);
+ EXPECT_EQ(ModelUtils::topItemNames(&model, "MultiLayer").at(0), QString("name1"));
+ EXPECT_EQ(ModelUtils::topItemNames(&model, "MultiLayer").at(1), QString("name2"));
// checking names of all top items
- QStringList expected = {"name1", Constants::LayerType, "name2"};
+ QStringList expected = {"name1", "Layer", "name2"};
EXPECT_EQ(ModelUtils::topItemNames(&model), expected);
}
@@ -68,7 +67,7 @@ TEST_F(TestModelUtils, test_emptyModel)
TEST_F(TestModelUtils, test_vectorItem)
{
SessionModel model("TestModel");
- SessionItem* vectorItem = model.insertNewItem(Constants::VectorType);
+ SessionItem* vectorItem = model.insertNewItem("Vector");
QVector<QModelIndex> indices;
@@ -94,8 +93,8 @@ TEST_F(TestModelUtils, test_vectorItem)
TEST_F(TestModelUtils, test_iterateIf)
{
SessionModel model("TestModel");
- SessionItem* multilayer = model.insertNewItem(Constants::MultiLayerType);
- SessionItem* layer = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
+ SessionItem* multilayer = model.insertNewItem("MultiLayer");
+ SessionItem* layer = model.insertNewItem("Layer", model.indexOfItem(multilayer));
SessionItem* thicknessItem = layer->getItem(LayerItem::P_THICKNESS);
layer->setVisible(true);
diff --git a/Tests/UnitTests/GUI/TestMultiLayerItem.cpp b/Tests/UnitTests/GUI/TestMultiLayerItem.cpp
index 97539e17a2be7073ba2803a0aff67d2b45449156..1ae171f1e59dc97c0b707b9dce37301d809ff066 100644
--- a/Tests/UnitTests/GUI/TestMultiLayerItem.cpp
+++ b/Tests/UnitTests/GUI/TestMultiLayerItem.cpp
@@ -1,7 +1,6 @@
#include "GUI/coregui/Models/LayerItem.h"
#include "GUI/coregui/Models/MultiLayerItem.h"
#include "GUI/coregui/Models/SampleModel.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "Tests/UnitTests/utilities/google_test.h"
class TestMultiLayerItem : public ::testing::Test
@@ -16,9 +15,9 @@ TEST_F(TestMultiLayerItem, test_twoLayerSystem)
{
SampleModel model;
- auto multilayer = model.insertNewItem(Constants::MultiLayerType);
- auto top = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
- auto bottom = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
+ auto multilayer = model.insertNewItem("MultiLayer");
+ auto top = model.insertNewItem("Layer", model.indexOfItem(multilayer));
+ auto bottom = model.insertNewItem("Layer", model.indexOfItem(multilayer));
// Thickness property should be disabled for top and bottom layers
EXPECT_FALSE(top->getItem(LayerItem::P_THICKNESS)->isEnabled());
@@ -34,9 +33,9 @@ TEST_F(TestMultiLayerItem, test_twoLayerSystem)
// Default roughness should be "LayerZeroRoughness"
EXPECT_EQ(top->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(),
- Constants::LayerZeroRoughnessType);
+ "LayerZeroRoughness");
EXPECT_EQ(bottom->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(),
- Constants::LayerZeroRoughnessType);
+ "LayerZeroRoughness");
}
//! Testing layer appearance (enabled, disabled) in a MultiLayer made of three default layers.
@@ -47,10 +46,10 @@ TEST_F(TestMultiLayerItem, test_threeLayerSystem)
{
SampleModel model;
- auto multilayer = model.insertNewItem(Constants::MultiLayerType);
- auto top = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
- auto middle = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
- auto bottom = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
+ auto multilayer = model.insertNewItem("MultiLayer");
+ auto top = model.insertNewItem("Layer", model.indexOfItem(multilayer));
+ auto middle = model.insertNewItem("Layer", model.indexOfItem(multilayer));
+ auto bottom = model.insertNewItem("Layer", model.indexOfItem(multilayer));
// Thickness property should be disabled for top and bottom layers and enabled for middle
EXPECT_FALSE(top->getItem(LayerItem::P_THICKNESS)->isEnabled());
@@ -69,11 +68,11 @@ TEST_F(TestMultiLayerItem, test_threeLayerSystem)
// Default roughness should be "LayerZeroRoughness"
EXPECT_EQ(top->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(),
- Constants::LayerZeroRoughnessType);
+ "LayerZeroRoughness");
EXPECT_EQ(middle->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(),
- Constants::LayerZeroRoughnessType);
+ "LayerZeroRoughness");
EXPECT_EQ(bottom->getGroupItem(LayerItem::P_ROUGHNESS)->modelType(),
- Constants::LayerZeroRoughnessType);
+ "LayerZeroRoughness");
}
//! Testing middle layer appearance when it is moved to the top.
@@ -85,10 +84,10 @@ TEST_F(TestMultiLayerItem, test_movingMiddleLayerOnTop)
{
SampleModel model;
- auto multilayer = model.insertNewItem(Constants::MultiLayerType);
- auto top = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
- auto middle = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
- auto bottom = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
+ auto multilayer = model.insertNewItem("MultiLayer");
+ auto top = model.insertNewItem("Layer", model.indexOfItem(multilayer));
+ auto middle = model.insertNewItem("Layer", model.indexOfItem(multilayer));
+ auto bottom = model.insertNewItem("Layer", model.indexOfItem(multilayer));
const double thickness = 10.0;
middle->setItemValue(LayerItem::P_THICKNESS, thickness);
@@ -111,8 +110,8 @@ TEST_F(TestMultiLayerItem, test_movingMiddleLayerOnTop)
// Moving middle layer to top
model.moveItem(middle, multilayer, 0, MultiLayerItem::T_LAYERS);
// checking that middle is top now, and top layer is middle now
- EXPECT_EQ(middle, multilayer->getChildrenOfType(Constants::LayerType).at(0));
- EXPECT_EQ(top, multilayer->getChildrenOfType(Constants::LayerType).at(1));
+ EXPECT_EQ(middle, multilayer->getChildrenOfType("Layer").at(0));
+ EXPECT_EQ(top, multilayer->getChildrenOfType("Layer").at(1));
// Thickness and roughness of middle layer should be disabled now
EXPECT_FALSE(middle->getItem(LayerItem::P_THICKNESS)->isEnabled());
@@ -133,9 +132,9 @@ TEST_F(TestMultiLayerItem, test_movingLayerOnCanvas)
{
SampleModel model;
- auto multilayer = model.insertNewItem(Constants::MultiLayerType);
- auto top = model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
- model.insertNewItem(Constants::LayerType, model.indexOfItem(multilayer));
+ auto multilayer = model.insertNewItem("MultiLayer");
+ auto top = model.insertNewItem("Layer", model.indexOfItem(multilayer));
+ model.insertNewItem("Layer", model.indexOfItem(multilayer));
// Moving top layer to canvas
model.moveItem(top, nullptr);
diff --git a/Tests/UnitTests/GUI/TestOutputDataIOService.cpp b/Tests/UnitTests/GUI/TestOutputDataIOService.cpp
index 053e88020ef94fc85922ddeac2b9728496de6b6f..cc90b3c421a34211621aeb3b39dd4d5fb4a57cae 100644
--- a/Tests/UnitTests/GUI/TestOutputDataIOService.cpp
+++ b/Tests/UnitTests/GUI/TestOutputDataIOService.cpp
@@ -45,20 +45,20 @@ TEST_F(TestOutputDataIOService, test_nonXMLData)
// adding RealDataItem
RealDataItem* realData =
- dynamic_cast<RealDataItem*>(models.realDataModel()->insertNewItem(Constants::RealDataType));
+ dynamic_cast<RealDataItem*>(models.realDataModel()->insertNewItem("RealData"));
EXPECT_EQ(models.realDataModel()->nonXMLData().size(), 0);
realData->setOutputData(TestUtils::createData().release());
EXPECT_EQ(models.realDataModel()->nonXMLData().size(), 1);
// adding JobItem
- SessionItem* jobItem = models.jobModel()->insertNewItem(Constants::JobItemType);
+ SessionItem* jobItem = models.jobModel()->insertNewItem("JobItem");
SessionItem* dataItem = models.jobModel()->insertNewItem(
- Constants::IntensityDataType, jobItem->index(), -1, JobItem::T_OUTPUT);
+ "IntensityData", jobItem->index(), -1, JobItem::T_OUTPUT);
EXPECT_EQ(models.jobModel()->nonXMLData().size(), 1);
// adding RealDataItem to jobItem
RealDataItem* realData2 = dynamic_cast<RealDataItem*>(models.jobModel()->insertNewItem(
- Constants::RealDataType, jobItem->index(), -1, JobItem::T_REALDATA));
+ "RealData", jobItem->index(), -1, JobItem::T_REALDATA));
EXPECT_EQ(models.jobModel()->nonXMLData().size(), 1);
realData2->setOutputData(TestUtils::createData(0.0, TestUtils::DIM::D1).release());
EXPECT_EQ(models.jobModel()->nonXMLData().size(), 2);
@@ -90,7 +90,7 @@ TEST_F(TestOutputDataIOService, test_nonXMLData)
TEST_F(TestOutputDataIOService, test_OutputDataSaveInfo)
{
SessionModel model("TempModel");
- DataItem* item = dynamic_cast<DataItem*>(model.insertNewItem(Constants::IntensityDataType));
+ DataItem* item = dynamic_cast<DataItem*>(model.insertNewItem("IntensityData"));
item->setLastModified(QDateTime::currentDateTime());
@@ -111,9 +111,9 @@ TEST_F(TestOutputDataIOService, test_OutputDataSaveInfo)
TEST_F(TestOutputDataIOService, test_OutputDataDirHistory)
{
SessionModel model("TempModel");
- DataItem* item1 = dynamic_cast<DataItem*>(model.insertNewItem(Constants::IntensityDataType));
+ DataItem* item1 = dynamic_cast<DataItem*>(model.insertNewItem("IntensityData"));
- DataItem* item2 = dynamic_cast<DataItem*>(model.insertNewItem(Constants::IntensityDataType));
+ DataItem* item2 = dynamic_cast<DataItem*>(model.insertNewItem("IntensityData"));
item1->setOutputData(m_data.clone());
item1->setLastModified(QDateTime::currentDateTime());
item2->setLastModified(QDateTime::currentDateTime());
@@ -148,9 +148,9 @@ TEST_F(TestOutputDataIOService, test_OutputDataDirHistory)
TEST_F(TestOutputDataIOService, test_OutputDataIOHistory)
{
SessionModel model("TempModel");
- DataItem* item1 = dynamic_cast<DataItem*>(model.insertNewItem(Constants::IntensityDataType));
+ DataItem* item1 = dynamic_cast<DataItem*>(model.insertNewItem("IntensityData"));
- DataItem* item2 = dynamic_cast<DataItem*>(model.insertNewItem(Constants::IntensityDataType));
+ DataItem* item2 = dynamic_cast<DataItem*>(model.insertNewItem("IntensityData"));
item1->setOutputData(m_data.clone());
item2->setOutputData(m_data.clone());
@@ -203,8 +203,8 @@ TEST_F(TestOutputDataIOService, test_OutputDataIOService)
QTest::qSleep(10);
// Checking existance of data on disk
- QString fname1 = "./" + projectDir + "/" + "realdata_data1_0.int.gz";
- QString fname2 = "./" + projectDir + "/" + "realdata_data2_0.int.gz";
+ QString fname1 = "./" + projectDir + "/realdata_data1_0.int.gz";
+ QString fname2 = "./" + projectDir + "/realdata_data2_0.int.gz";
EXPECT_TRUE(ProjectUtils::exists(fname1));
EXPECT_TRUE(ProjectUtils::exists(fname2));
@@ -233,7 +233,7 @@ TEST_F(TestOutputDataIOService, test_OutputDataIOService)
service.save(projectDir);
QTest::qSleep(10);
- QString fname2new = "./" + projectDir + "/" + "realdata_data2new_0.int.gz";
+ QString fname2new = "./" + projectDir + "/realdata_data2new_0.int.gz";
EXPECT_TRUE(ProjectUtils::exists(fname2new));
EXPECT_TRUE(TestUtils::isTheSame(fname2new, *realData2->dataItem()->getOutputData()));
@@ -251,11 +251,11 @@ TEST_F(TestOutputDataIOService, test_RealDataItemWithNativeData)
// adding RealDataItem
RealDataItem* realData =
- dynamic_cast<RealDataItem*>(models.realDataModel()->insertNewItem(Constants::RealDataType));
+ dynamic_cast<RealDataItem*>(models.realDataModel()->insertNewItem("RealData"));
EXPECT_EQ(models.realDataModel()->nonXMLData().size(), 0);
ImportDataInfo import_data(std::unique_ptr<OutputData<double>>(m_data.clone()),
- Constants::UnitsNbins);
+ "nbins");
realData->setImportData(std::move(import_data));
EXPECT_EQ(models.realDataModel()->nonXMLData().size(), 2);
@@ -263,9 +263,9 @@ TEST_F(TestOutputDataIOService, test_RealDataItemWithNativeData)
// adding JobItem
JobItem* jobItem =
- dynamic_cast<JobItem*>(models.jobModel()->insertNewItem(Constants::JobItemType));
+ dynamic_cast<JobItem*>(models.jobModel()->insertNewItem("JobItem"));
jobItem->setIdentifier(GUIHelpers::createUuid());
- models.jobModel()->insertNewItem(Constants::IntensityDataType, jobItem->index(), -1,
+ models.jobModel()->insertNewItem("IntensityData", jobItem->index(), -1,
JobItem::T_OUTPUT);
EXPECT_EQ(models.jobModel()->nonXMLData().size(), 1);
diff --git a/Tests/UnitTests/GUI/TestParaCrystalItems.cpp b/Tests/UnitTests/GUI/TestParaCrystalItems.cpp
index c3b55165752f99aebc95f59c47e3e7fe315365e6..192c6c412eea0c176a73871a565f2ee945fc74b5 100644
--- a/Tests/UnitTests/GUI/TestParaCrystalItems.cpp
+++ b/Tests/UnitTests/GUI/TestParaCrystalItems.cpp
@@ -8,7 +8,6 @@
#include "GUI/coregui/Models/ParticleLayoutItem.h"
#include "GUI/coregui/Models/SampleModel.h"
#include "GUI/coregui/Models/TransformFromDomain.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "Tests/UnitTests/utilities/google_test.h"
class TestParaCrystalItems : public ::testing::Test
@@ -44,20 +43,20 @@ TEST_F(TestParaCrystalItems, test_Para2D_fromToDomain)
orig.integrationOverXi());
SessionItem* latticeItem = item.getGroupItem(InterferenceFunction2DLatticeItem::P_LATTICE_TYPE);
- EXPECT_EQ(latticeItem->modelType(), Constants::BasicLatticeType);
+ EXPECT_EQ(latticeItem->modelType(), "BasicLattice");
EXPECT_EQ(latticeItem->getItemValue(BasicLatticeItem::P_LATTICE_LENGTH1).toDouble(), length1);
EXPECT_EQ(latticeItem->getItemValue(BasicLatticeItem::P_LATTICE_LENGTH2).toDouble(), length2);
EXPECT_EQ(latticeItem->getItemValue(BasicLatticeItem::P_LATTICE_ANGLE).toDouble(), angle);
EXPECT_EQ(latticeItem->getItemValue(Lattice2DItem::P_LATTICE_ROTATION_ANGLE).toDouble(), xi);
SessionItem* pdfItem1 = item.getGroupItem(InterferenceFunction2DParaCrystalItem::P_PDF1);
- EXPECT_EQ(pdfItem1->modelType(), Constants::FTDistribution2DCauchyType);
+ EXPECT_EQ(pdfItem1->modelType(), "FTDistribution2DCauchy");
EXPECT_EQ(pdfItem1->getItemValue(FTDistribution2DItem::P_OMEGA_X).toDouble(), clength_x);
EXPECT_EQ(pdfItem1->getItemValue(FTDistribution2DItem::P_OMEGA_Y).toDouble(), clength_y);
EXPECT_EQ(pdfItem1->getItemValue(FTDistribution2DItem::P_GAMMA).toDouble(), gamma);
SessionItem* pdfItem2 = item.getGroupItem(InterferenceFunction2DParaCrystalItem::P_PDF2);
- EXPECT_EQ(pdfItem2->modelType(), Constants::FTDistribution2DGaussType);
+ EXPECT_EQ(pdfItem2->modelType(), "FTDistribution2DGauss");
EXPECT_EQ(pdfItem2->getItemValue(FTDistribution2DItem::P_OMEGA_X).toDouble(), clength_x);
EXPECT_EQ(pdfItem2->getItemValue(FTDistribution2DItem::P_OMEGA_Y).toDouble(), clength_y);
EXPECT_EQ(pdfItem2->getItemValue(FTDistribution2DItem::P_GAMMA).toDouble(), gamma);
@@ -78,12 +77,12 @@ TEST_F(TestParaCrystalItems, test_Para2D_fromToDomain)
TEST_F(TestParaCrystalItems, test_Inference2DRotationAngleToggle)
{
SampleModel model;
- SessionItem* multilayer = model.insertNewItem(Constants::MultiLayerType);
- SessionItem* layer = model.insertNewItem(Constants::LayerType, multilayer->index());
- SessionItem* layout = model.insertNewItem(Constants::ParticleLayoutType, layer->index());
+ SessionItem* multilayer = model.insertNewItem("MultiLayer");
+ SessionItem* layer = model.insertNewItem("Layer", multilayer->index());
+ SessionItem* layout = model.insertNewItem("ParticleLayout", layer->index());
SessionItem* interference =
- model.insertNewItem(Constants::InterferenceFunction2DParaCrystalType, layout->index(), -1,
+ model.insertNewItem("Interference2DParaCrystal", layout->index(), -1,
ParticleLayoutItem::T_INTERFERENCE);
// rotation (xi) should be disabled if integration is on
diff --git a/Tests/UnitTests/GUI/TestParameterTreeUtils.cpp b/Tests/UnitTests/GUI/TestParameterTreeUtils.cpp
index 0e6ccd9ed7eb4cb33628bbb3250b6a5c39ce4544..b8622b3547fbcf2036d51c74e2d627b4f827a57b 100644
--- a/Tests/UnitTests/GUI/TestParameterTreeUtils.cpp
+++ b/Tests/UnitTests/GUI/TestParameterTreeUtils.cpp
@@ -29,10 +29,10 @@ TEST_F(TestParameterTreeUtils, test_parameterTreeNames)
{
SampleModel model;
- SessionItem* layer = model.insertNewItem(Constants::LayerType);
+ SessionItem* layer = model.insertNewItem("Layer");
EXPECT_EQ(ParameterTreeUtils::parameterTreeNames(layer), QStringList() << "Layer/Thickness");
- SessionItem* particle = model.insertNewItem(Constants::ParticleType);
+ SessionItem* particle = model.insertNewItem("Particle");
EXPECT_EQ(ParameterTreeUtils::parameterTreeNames(particle), expectedParticleParameterNames);
}
@@ -42,7 +42,7 @@ TEST_F(TestParameterTreeUtils, test_parameterTranslatedNames)
{
SampleModel model;
- SessionItem* particle = model.insertNewItem(Constants::ParticleType);
+ SessionItem* particle = model.insertNewItem("Particle");
EXPECT_EQ(ParameterTreeUtils::translatedParameterTreeNames(particle),
expectedParticleParameterTranslations);
@@ -54,11 +54,11 @@ TEST_F(TestParameterTreeUtils, test_linkItemFromParameterName)
{
SampleModel model;
- SessionItem* particle = model.insertNewItem(Constants::ParticleType);
+ SessionItem* particle = model.insertNewItem("Particle");
auto ffItem = static_cast<FormFactorItem*>(particle->getGroupItem(ParticleItem::P_FORM_FACTOR));
Q_ASSERT(ffItem);
- EXPECT_EQ(ffItem->modelType(), Constants::CylinderType);
+ EXPECT_EQ(ffItem->modelType(), "Cylinder");
EXPECT_EQ(ffItem->getItem(CylinderItem::P_RADIUS),
ParameterTreeUtils::parameterNameToLinkedItem("Particle/Cylinder/Radius", particle));
diff --git a/Tests/UnitTests/GUI/TestParticleCoreShell.cpp b/Tests/UnitTests/GUI/TestParticleCoreShell.cpp
index d70dc544dc1f06e2ec0b209bce890fcfeb32644b..8f3abbdf66a371ab48423b39ab5ea86476496c9b 100644
--- a/Tests/UnitTests/GUI/TestParticleCoreShell.cpp
+++ b/Tests/UnitTests/GUI/TestParticleCoreShell.cpp
@@ -17,10 +17,10 @@ class TestParticleCoreShell : public ::testing::Test
TEST_F(TestParticleCoreShell, test_moveCoreAndShell)
{
SampleModel model;
- SessionItem* coreshell = model.insertNewItem(Constants::ParticleCoreShellType);
- SessionItem* particle1 = model.insertNewItem(Constants::ParticleType);
- SessionItem* particle2 = model.insertNewItem(Constants::ParticleType);
- SessionItem* particle3 = model.insertNewItem(Constants::ParticleType);
+ SessionItem* coreshell = model.insertNewItem("ParticleCoreShell");
+ SessionItem* particle1 = model.insertNewItem("Particle");
+ SessionItem* particle2 = model.insertNewItem("Particle");
+ SessionItem* particle3 = model.insertNewItem("Particle");
// empty coreshell particle
EXPECT_EQ(particle1->parent(), model.rootItem());
@@ -54,7 +54,7 @@ TEST_F(TestParticleCoreShell, test_propertyAppearance)
SampleModel model;
// empty coreshell particle
- SessionItem* coreshell = model.insertNewItem(Constants::ParticleCoreShellType);
+ SessionItem* coreshell = model.insertNewItem("ParticleCoreShell");
EXPECT_TRUE(coreshell->getItem(ParticleItem::P_ABUNDANCE)->isEnabled());
EXPECT_EQ(coreshell->getItemValue(ParticleItem::P_ABUNDANCE).toDouble(), 1.0);
EXPECT_TRUE(coreshell->getItem(ParticleItem::P_POSITION)->isEnabled());
@@ -64,7 +64,7 @@ TEST_F(TestParticleCoreShell, test_propertyAppearance)
EXPECT_EQ(pos.z(), 0.0);
// adding core, and checking that abundance is disabled
- SessionItem* core = model.insertNewItem(Constants::ParticleType, coreshell->index(), -1,
+ SessionItem* core = model.insertNewItem("Particle", coreshell->index(), -1,
ParticleCoreShellItem::T_CORE);
EXPECT_FALSE(core->getItem(ParticleItem::P_ABUNDANCE)->isEnabled());
EXPECT_TRUE(core->getItem(ParticleItem::P_POSITION)->isEnabled());
@@ -76,7 +76,7 @@ TEST_F(TestParticleCoreShell, test_propertyAppearance)
delete core;
// creating shell (not yet attached to the coreshell)
- SessionItem* shell = model.insertNewItem(Constants::ParticleType);
+ SessionItem* shell = model.insertNewItem("Particle");
SessionItem* positionItem = shell->getItem(ParticleItem::P_POSITION);
// putting some values to position and abundance
shell->setItemValue(ParticleItem::P_ABUNDANCE, 0.2);
@@ -104,13 +104,13 @@ TEST_F(TestParticleCoreShell, test_distributionContext)
SampleModel model;
// coreshell particle
- SessionItem* coreshell = model.insertNewItem(Constants::ParticleCoreShellType);
+ SessionItem* coreshell = model.insertNewItem("ParticleCoreShell");
coreshell->setItemValue(ParticleItem::P_ABUNDANCE, 0.2);
EXPECT_TRUE(coreshell->getItem(ParticleItem::P_ABUNDANCE)->isEnabled() == true);
EXPECT_EQ(coreshell->getItemValue(ParticleItem::P_ABUNDANCE).toDouble(), 0.2);
// create distribution, adding coreshell to it
- SessionItem* distribution = model.insertNewItem(Constants::ParticleDistributionType);
+ SessionItem* distribution = model.insertNewItem("ParticleDistribution");
model.moveItem(coreshell, distribution, -1, ParticleDistributionItem::T_PARTICLES);
// checking abundance has switched to defaults
EXPECT_FALSE(coreshell->getItem(ParticleItem::P_ABUNDANCE)->isEnabled());
@@ -129,13 +129,13 @@ TEST_F(TestParticleCoreShell, test_compositionContext)
SampleModel model;
// coreshell particle
- SessionItem* coreshell = model.insertNewItem(Constants::ParticleCoreShellType);
+ SessionItem* coreshell = model.insertNewItem("ParticleCoreShell");
coreshell->setItemValue(ParticleItem::P_ABUNDANCE, 0.2);
EXPECT_TRUE(coreshell->getItem(ParticleItem::P_ABUNDANCE)->isEnabled());
EXPECT_EQ(coreshell->getItemValue(ParticleItem::P_ABUNDANCE).toDouble(), 0.2);
// create composition, adding coreshell to it
- SessionItem* composition = model.insertNewItem(Constants::ParticleCompositionType);
+ SessionItem* composition = model.insertNewItem("ParticleComposition");
model.moveItem(coreshell, composition, -1, ParticleCompositionItem::T_PARTICLES);
// checking abundance has switched to defaults
EXPECT_FALSE(coreshell->getItem(ParticleItem::P_ABUNDANCE)->isEnabled());
diff --git a/Tests/UnitTests/GUI/TestParticleDistributionItem.cpp b/Tests/UnitTests/GUI/TestParticleDistributionItem.cpp
index 081eb4d8996b7faf4bd276157df35ebd5ab517ea..b9483ef0bdf87f62aa47d9ad962cfe91680fe5a3 100644
--- a/Tests/UnitTests/GUI/TestParticleDistributionItem.cpp
+++ b/Tests/UnitTests/GUI/TestParticleDistributionItem.cpp
@@ -40,9 +40,9 @@ class TestParticleDistributionItem : public ::testing::Test
TEST_F(TestParticleDistributionItem, test_InitialState)
{
SampleModel model;
- SessionItem* distItem = model.insertNewItem(Constants::ParticleDistributionType);
+ SessionItem* distItem = model.insertNewItem("ParticleDistribution");
- EXPECT_EQ(distItem->displayName(), Constants::ParticleDistributionType);
+ EXPECT_EQ(distItem->displayName(), "ParticleDistribution");
EXPECT_EQ(distItem->displayName(), distItem->itemName());
// xpos, ypos, P_ABUNDANCE, P_DISTRIBUTION, P_DISTRIBUTED_PARAMETER
@@ -51,9 +51,9 @@ TEST_F(TestParticleDistributionItem, test_InitialState)
EXPECT_EQ(distItem->defaultTag(), ParticleDistributionItem::T_PARTICLES);
EXPECT_EQ(distItem->acceptableDefaultItemTypes(),
- QVector<QString>() << Constants::ParticleType << Constants::ParticleCoreShellType
- << Constants::ParticleCompositionType
- << Constants::MesoCrystalType);
+ QVector<QString>() << "Particle" << "ParticleCoreShell"
+ << "ParticleComposition"
+ << "MesoCrystal");
// main parameter
ComboProperty prop = distItem->getItemValue(ParticleDistributionItem::P_DISTRIBUTED_PARAMETER)
@@ -71,10 +71,10 @@ TEST_F(TestParticleDistributionItem, test_InitialState)
TEST_F(TestParticleDistributionItem, test_AddParticle)
{
SampleModel model;
- SessionItem* dist = model.insertNewItem(Constants::ParticleDistributionType);
+ SessionItem* dist = model.insertNewItem("ParticleDistribution");
// adding default particle and checking list of available parameters
- SessionItem* particle = model.insertNewItem(Constants::ParticleType, dist->index());
+ SessionItem* particle = model.insertNewItem("Particle", dist->index());
EXPECT_EQ(dist->getItems().size(), 1);
@@ -93,7 +93,7 @@ TEST_F(TestParticleDistributionItem, test_AddParticle)
EXPECT_EQ(prop.getValue(), "");
// changing form factor of the particle
- particle->setGroupProperty(ParticleItem::P_FORM_FACTOR, Constants::BoxType);
+ particle->setGroupProperty(ParticleItem::P_FORM_FACTOR, "Box");
prop = dist->getItemValue(ParticleDistributionItem::P_DISTRIBUTED_PARAMETER)
.value<ComboProperty>();
@@ -116,8 +116,8 @@ TEST_F(TestParticleDistributionItem, test_AddParticle)
TEST_F(TestParticleDistributionItem, test_MainLinkedCorrelation)
{
SampleModel model;
- SessionItem* dist = model.insertNewItem(Constants::ParticleDistributionType);
- model.insertNewItem(Constants::ParticleType, dist->index());
+ SessionItem* dist = model.insertNewItem("ParticleDistribution");
+ model.insertNewItem("Particle", dist->index());
ComboProperty mainCombo = dist->getItemValue(ParticleDistributionItem::P_DISTRIBUTED_PARAMETER)
.value<ComboProperty>();
@@ -188,10 +188,10 @@ TEST_F(TestParticleDistributionItem, test_FromDomain)
// creating GUI distribution
SampleModel model;
- SessionItem* distItem = model.insertNewItem(Constants::ParticleDistributionType);
- SessionItem* particleItem = model.insertNewItem(Constants::ParticleType, distItem->index());
+ SessionItem* distItem = model.insertNewItem("ParticleDistribution");
+ SessionItem* particleItem = model.insertNewItem("Particle", distItem->index());
- particleItem->setGroupProperty(ParticleItem::P_FORM_FACTOR, Constants::AnisoPyramidType);
+ particleItem->setGroupProperty(ParticleItem::P_FORM_FACTOR, "AnisoPyramid");
// Sets it from domain
TransformFromDomain::setParticleDistributionItem(distItem, particle_collection);
@@ -202,7 +202,7 @@ TEST_F(TestParticleDistributionItem, test_FromDomain)
EXPECT_EQ(prop.getValue(), ParticleDistributionItem::NO_SELECTION);
// changing particle type and check that distribution picked up domain name
- particleItem->setGroupProperty(ParticleItem::P_FORM_FACTOR, Constants::CylinderType);
+ particleItem->setGroupProperty(ParticleItem::P_FORM_FACTOR, "Cylinder");
prop = distItem->getItemValue(ParticleDistributionItem::P_DISTRIBUTED_PARAMETER)
.value<ComboProperty>();
@@ -227,10 +227,10 @@ TEST_F(TestParticleDistributionItem, test_FromDomainLinked)
// creating GUI distribution
SampleModel model;
- SessionItem* distItem = model.insertNewItem(Constants::ParticleDistributionType);
- SessionItem* particleItem = model.insertNewItem(Constants::ParticleType, distItem->index());
+ SessionItem* distItem = model.insertNewItem("ParticleDistribution");
+ SessionItem* particleItem = model.insertNewItem("Particle", distItem->index());
- particleItem->setGroupProperty(ParticleItem::P_FORM_FACTOR, Constants::AnisoPyramidType);
+ particleItem->setGroupProperty(ParticleItem::P_FORM_FACTOR, "AnisoPyramid");
// Sets it from domain
TransformFromDomain::setParticleDistributionItem(distItem, particle_collection);
@@ -244,7 +244,7 @@ TEST_F(TestParticleDistributionItem, test_FromDomainLinked)
EXPECT_EQ(linkedProp.getValue(), "");
// changing particle type and check that distribution picked up domain name
- particleItem->setGroupProperty(ParticleItem::P_FORM_FACTOR, Constants::CylinderType);
+ particleItem->setGroupProperty(ParticleItem::P_FORM_FACTOR, "Cylinder");
prop = distItem->getItemValue(ParticleDistributionItem::P_DISTRIBUTED_PARAMETER)
.value<ComboProperty>();
@@ -273,8 +273,8 @@ TEST_F(TestParticleDistributionItem, test_FromDomainWithLimits)
// creating GUI distribution
SampleModel model;
- SessionItem* partDistItem = model.insertNewItem(Constants::ParticleDistributionType);
- model.insertNewItem(Constants::ParticleType, partDistItem->index());
+ SessionItem* partDistItem = model.insertNewItem("ParticleDistribution");
+ model.insertNewItem("Particle", partDistItem->index());
// Sets it from domain
TransformFromDomain::setParticleDistributionItem(partDistItem, particle_collection);
@@ -293,8 +293,8 @@ TEST_F(TestParticleDistributionItem, test_Clone)
std::unique_ptr<MaterialModel> P_materialModel(new MaterialModel());
SampleModel model1;
- SessionItem* dist = model1.insertNewItem(Constants::ParticleDistributionType);
- model1.insertNewItem(Constants::ParticleType, dist->index());
+ SessionItem* dist = model1.insertNewItem("ParticleDistribution");
+ model1.insertNewItem("Particle", dist->index());
QString buffer1;
QXmlStreamWriter writer1(&buffer1);
diff --git a/Tests/UnitTests/GUI/TestParticleItem.cpp b/Tests/UnitTests/GUI/TestParticleItem.cpp
index 3dac3f652984c924326af2ccde43fa0d031baf4f..77b1b635bc45fa99b078003178a37ce526d76a9c 100644
--- a/Tests/UnitTests/GUI/TestParticleItem.cpp
+++ b/Tests/UnitTests/GUI/TestParticleItem.cpp
@@ -16,9 +16,9 @@ class TestParticleItem : public ::testing::Test
TEST_F(TestParticleItem, test_InitialState)
{
SampleModel model;
- SessionItem* item = model.insertNewItem(Constants::ParticleType);
+ SessionItem* item = model.insertNewItem("Particle");
- EXPECT_EQ(item->displayName(), Constants::ParticleType);
+ EXPECT_EQ(item->displayName(), "Particle");
EXPECT_EQ(item->displayName(), item->itemName());
// xpos, ypos, P_FORM_FACTOR, P_MATERIAL, P_ABUNDANCE, P_POSITION
EXPECT_EQ(item->children().size(), 6);
@@ -32,13 +32,13 @@ TEST_F(TestParticleItem, test_InitialState)
TEST_F(TestParticleItem, test_compositionContext)
{
SampleModel model;
- SessionItem* particle = model.insertNewItem(Constants::ParticleType);
+ SessionItem* particle = model.insertNewItem("Particle");
particle->setItemValue(ParticleItem::P_ABUNDANCE, 0.2);
EXPECT_TRUE(particle->getItem(ParticleItem::P_ABUNDANCE)->isEnabled());
EXPECT_EQ(particle->getItemValue(ParticleItem::P_ABUNDANCE).toDouble(), 0.2);
// adding particle to composition, checking that abundance is default
- SessionItem* composition = model.insertNewItem(Constants::ParticleCompositionType);
+ SessionItem* composition = model.insertNewItem("ParticleComposition");
model.moveItem(particle, composition, -1, ParticleCompositionItem::T_PARTICLES);
EXPECT_FALSE(particle->getItem(ParticleItem::P_ABUNDANCE)->isEnabled());
EXPECT_EQ(particle->getItemValue(ParticleItem::P_ABUNDANCE).toDouble(), 1.0);
@@ -52,13 +52,13 @@ TEST_F(TestParticleItem, test_compositionContext)
TEST_F(TestParticleItem, test_distributionContext)
{
SampleModel model;
- SessionItem* particle = model.insertNewItem(Constants::ParticleType);
+ SessionItem* particle = model.insertNewItem("Particle");
particle->setItemValue(ParticleItem::P_ABUNDANCE, 0.2);
EXPECT_TRUE(particle->getItem(ParticleItem::P_ABUNDANCE)->isEnabled() == true);
EXPECT_EQ(particle->getItemValue(ParticleItem::P_ABUNDANCE).toDouble(), 0.2);
// adding particle to distribution, checking that abundance is default
- SessionItem* distribution = model.insertNewItem(Constants::ParticleDistributionType);
+ SessionItem* distribution = model.insertNewItem("ParticleDistribution");
model.moveItem(particle, distribution, -1, ParticleDistributionItem::T_PARTICLES);
EXPECT_TRUE(particle->getItem(ParticleItem::P_ABUNDANCE)->isEnabled() == false);
EXPECT_EQ(particle->getItemValue(ParticleItem::P_ABUNDANCE).toDouble(), 1.0);
diff --git a/Tests/UnitTests/GUI/TestParticleLayoutItem.h b/Tests/UnitTests/GUI/TestParticleLayoutItem.h
index 95a118276504967655fff7dd8e69a21ac10e9f0a..855353fc23a35e7033df8eff3b7619d7f674d20f 100644
--- a/Tests/UnitTests/GUI/TestParticleLayoutItem.h
+++ b/Tests/UnitTests/GUI/TestParticleLayoutItem.h
@@ -18,14 +18,14 @@ TEST_F(TestParticleLayoutItem, densityAppearance)
{
SampleModel model;
auto layout =
- dynamic_cast<ParticleLayoutItem*>(model.insertNewItem(Constants::ParticleLayoutType));
+ dynamic_cast<ParticleLayoutItem*>(model.insertNewItem("ParticleLayout"));
// empty layout should have TotalDensity enabled
EXPECT_TRUE(layout->getItem(ParticleLayoutItem::P_TOTAL_DENSITY)->isEnabled());
// adding radial paracrystal shouldn't change it
auto interference =
- model.insertNewItem(Constants::InterferenceFunctionRadialParaCrystalType,
+ model.insertNewItem("InterferenceRadialParaCrystal",
model.indexOfItem(layout), -1, ParticleLayoutItem::T_INTERFERENCE);
EXPECT_TRUE(layout->getItem(ParticleLayoutItem::T_INTERFERENCE) == interference);
EXPECT_TRUE(layout->getItem(ParticleLayoutItem::P_TOTAL_DENSITY)->isEnabled());
@@ -38,7 +38,7 @@ TEST_F(TestParticleLayoutItem, densityAppearance)
// adding 2d interference, TotalDensity should be disabled
interference =
- model.insertNewItem(Constants::InterferenceFunction2DLatticeType, model.indexOfItem(layout),
+ model.insertNewItem("Interference2DLattice", model.indexOfItem(layout),
-1, ParticleLayoutItem::T_INTERFERENCE);
EXPECT_FALSE(layout->getItem(ParticleLayoutItem::P_TOTAL_DENSITY)->isEnabled());
@@ -57,19 +57,19 @@ TEST_F(TestParticleLayoutItem, densityValue)
{
SampleModel model;
auto layout =
- dynamic_cast<ParticleLayoutItem*>(model.insertNewItem(Constants::ParticleLayoutType));
+ dynamic_cast<ParticleLayoutItem*>(model.insertNewItem("ParticleLayout"));
// empty layout should have TotalDensity 0.01
EXPECT_EQ(layout->getItemValue(ParticleLayoutItem::P_TOTAL_DENSITY).toDouble(), 0.01);
// adding 2d interference with default hexagonal lattice
auto interference =
- model.insertNewItem(Constants::InterferenceFunction2DLatticeType, model.indexOfItem(layout),
+ model.insertNewItem("Interference2DLattice", model.indexOfItem(layout),
-1, ParticleLayoutItem::T_INTERFERENCE);
auto& hexItem =
interference->groupItem<Lattice2DItem>(InterferenceFunction2DLatticeItem::P_LATTICE_TYPE);
- EXPECT_EQ(hexItem.modelType(), Constants::HexagonalLatticeType);
+ EXPECT_EQ(hexItem.modelType(), "HexagonalLattice");
double length = hexItem.getItemValue(HexagonalLatticeItem::P_LATTICE_LENGTH).toDouble();
double expectedDensity = 1. / (length * length * std::sin(M_TWOPI / 3.0));
EXPECT_DOUBLE_EQ(1.0 / hexItem.unitCellArea(), expectedDensity);
@@ -85,10 +85,10 @@ TEST_F(TestParticleLayoutItem, densityValue)
// changing lattice type to square and checking new surface density
interference->setGroupProperty(InterferenceFunction2DLatticeItem::P_LATTICE_TYPE,
- Constants::SquareLatticeType);
+ "SquareLattice");
auto& squareItem =
interference->groupItem<Lattice2DItem>(InterferenceFunction2DLatticeItem::P_LATTICE_TYPE);
- EXPECT_EQ(squareItem.modelType(), Constants::SquareLatticeType);
+ EXPECT_EQ(squareItem.modelType(), "SquareLattice");
length = squareItem.getItemValue(SquareLatticeItem::P_LATTICE_LENGTH).toDouble();
expectedDensity = 1. / (length * length);
EXPECT_DOUBLE_EQ(1.0 / squareItem.unitCellArea(), expectedDensity);
diff --git a/Tests/UnitTests/GUI/TestPropertyRepeater.cpp b/Tests/UnitTests/GUI/TestPropertyRepeater.cpp
index e7f398d837cd6de482e644f8adf60aedda8b1fad..47ee55ce8a811b8d0a72106948c9ad5926e38e0f 100644
--- a/Tests/UnitTests/GUI/TestPropertyRepeater.cpp
+++ b/Tests/UnitTests/GUI/TestPropertyRepeater.cpp
@@ -1,7 +1,6 @@
#include "GUI/coregui/Models/AxesItems.h"
#include "GUI/coregui/Models/IntensityDataItem.h"
#include "GUI/coregui/Models/SessionModel.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/IntensityDataWidgets/PropertyRepeater.h"
#include "Tests/UnitTests/utilities/google_test.h"
@@ -10,12 +9,12 @@ namespace
IntensityDataItem* createData(SessionModel& model)
{
- return dynamic_cast<IntensityDataItem*>(model.insertNewItem(Constants::IntensityDataType));
+ return dynamic_cast<IntensityDataItem*>(model.insertNewItem("IntensityData"));
}
BasicAxisItem* createAxis(SessionModel& model)
{
- return dynamic_cast<BasicAxisItem*>(model.insertNewItem(Constants::BasicAxisType));
+ return dynamic_cast<BasicAxisItem*>(model.insertNewItem("BasicAxis"));
}
} // namespace
diff --git a/Tests/UnitTests/GUI/TestProxyModelStrategy.cpp b/Tests/UnitTests/GUI/TestProxyModelStrategy.cpp
index 4a92855f1fe3d5bc00cdc765e52d05483896d357..983a2ef80f935012a3931df973d6fe37fe04ff4c 100644
--- a/Tests/UnitTests/GUI/TestProxyModelStrategy.cpp
+++ b/Tests/UnitTests/GUI/TestProxyModelStrategy.cpp
@@ -6,7 +6,6 @@
#include "GUI/coregui/Models/ProxyModelStrategy.h"
#include "GUI/coregui/Models/SessionModel.h"
#include "GUI/coregui/Models/VectorItem.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "Tests/UnitTests/utilities/google_test.h"
class TestProxyModelStrategy : public ::testing::Test
@@ -30,7 +29,7 @@ TEST_F(TestProxyModelStrategy, test_identityStrategy)
EXPECT_EQ(strategy.proxySourceParent().size(), 0);
// building map when simple item
- SessionItem* item = model.insertNewItem(Constants::PropertyType);
+ SessionItem* item = model.insertNewItem("Property");
strategy.buildModelMap(&model, &proxy);
EXPECT_EQ(strategy.sourceToProxy().size(), 2);
EXPECT_EQ(strategy.proxySourceParent().size(), 2);
@@ -71,14 +70,14 @@ TEST_F(TestProxyModelStrategy, test_identityStrategyParticle)
ComponentProxyModel proxy;
IndentityProxyStrategy strategy;
- SessionItem* item = model.insertNewItem(Constants::ParticleType);
+ SessionItem* item = model.insertNewItem("Particle");
// building the map of source
strategy.buildModelMap(&model, &proxy);
SessionItem* group = item->getItem(ParticleItem::P_FORM_FACTOR);
SessionItem* ffItem = item->getGroupItem(ParticleItem::P_FORM_FACTOR);
EXPECT_TRUE(ffItem->parent() == group);
- EXPECT_TRUE(ffItem->modelType() == Constants::CylinderType);
+ EXPECT_TRUE(ffItem->modelType() == "Cylinder");
// Checking "real" parent of proxy index related to form factor.
// For identity model we are testing, it has to be just group property.
@@ -102,14 +101,14 @@ TEST_F(TestProxyModelStrategy, test_componentStrategyParticle)
ComponentProxyModel proxy;
ComponentProxyStrategy strategy;
- SessionItem* item = model.insertNewItem(Constants::ParticleType);
+ SessionItem* item = model.insertNewItem("Particle");
// building the map of source
strategy.buildModelMap(&model, &proxy);
SessionItem* group = item->getItem(ParticleItem::P_FORM_FACTOR);
SessionItem* ffItem = item->getGroupItem(ParticleItem::P_FORM_FACTOR);
EXPECT_TRUE(ffItem->parent() == group);
- EXPECT_TRUE(ffItem->modelType() == Constants::CylinderType);
+ EXPECT_TRUE(ffItem->modelType() == "Cylinder");
// original indices
QModelIndex particleIndex = model.indexOfItem(item);
@@ -142,7 +141,7 @@ TEST_F(TestProxyModelStrategy, test_setRootIndex)
ComponentProxyModel proxy;
ComponentProxyStrategy strategy;
- SessionItem* item = model.insertNewItem(Constants::ParticleType);
+ SessionItem* item = model.insertNewItem("Particle");
SessionItem* group = item->getItem(ParticleItem::P_FORM_FACTOR);
SessionItem* ffItem = item->getGroupItem(ParticleItem::P_FORM_FACTOR);
diff --git a/Tests/UnitTests/GUI/TestRealSpaceBuilderUtils.cpp b/Tests/UnitTests/GUI/TestRealSpaceBuilderUtils.cpp
index 66deaedb089467ca67cf192ee24b9675c2b38462..13ae1b808c55f413876cd42c39a6985839d25450 100644
--- a/Tests/UnitTests/GUI/TestRealSpaceBuilderUtils.cpp
+++ b/Tests/UnitTests/GUI/TestRealSpaceBuilderUtils.cpp
@@ -39,14 +39,14 @@ TEST_F(TestRealSpaceBuilderUtils, test_computeCumulativeAbundances)
{
SampleModel sampleModel;
auto layout =
- dynamic_cast<ParticleLayoutItem*>(sampleModel.insertNewItem(Constants::ParticleLayoutType));
+ dynamic_cast<ParticleLayoutItem*>(sampleModel.insertNewItem("ParticleLayout"));
auto particle1 =
- sampleModel.insertNewItem(Constants::ParticleType, sampleModel.indexOfItem(layout), -1,
+ sampleModel.insertNewItem("Particle", sampleModel.indexOfItem(layout), -1,
ParticleLayoutItem::T_PARTICLES);
EXPECT_EQ(particle1->parent(), layout);
- SessionItem* particle2 = sampleModel.insertNewItem(Constants::ParticleType);
+ SessionItem* particle2 = sampleModel.insertNewItem("Particle");
EXPECT_EQ(particle2->parent(), sampleModel.rootItem());
sampleModel.moveItem(particle2, layout, -1, ParticleLayoutItem::T_PARTICLES);
@@ -72,11 +72,11 @@ TEST_F(TestRealSpaceBuilderUtils, test_Particle3DContainer)
// Associate it to a Particle3DContainer object
p1.addParticle(cylinder3D.release(), false);
p1.setCumulativeAbundance(1);
- p1.setParticleType(Constants::ParticleType);
+ p1.setParticleType("Particle");
EXPECT_EQ(p1.containerSize(), 1u);
EXPECT_EQ(p1.cumulativeAbundance(), 1);
- EXPECT_EQ(p1.particleType(), Constants::ParticleType);
+ EXPECT_EQ(p1.particleType(), "Particle");
EXPECT_FALSE(p1.particle3DBlend(0u));
RealSpaceModel realSpaceModel;
@@ -88,14 +88,14 @@ TEST_F(TestRealSpaceBuilderUtils, test_Particle3DContainer)
EXPECT_EQ(p2.containerSize(), 1u);
EXPECT_EQ(p2.cumulativeAbundance(), 1);
- EXPECT_EQ(p2.particleType(), Constants::ParticleType);
+ EXPECT_EQ(p2.particleType(), "Particle");
EXPECT_FALSE(p2.particle3DBlend(0u));
Particle3DContainer p3 = Particle3DContainer(p1);
EXPECT_EQ(p3.containerSize(), 1u);
EXPECT_EQ(p3.cumulativeAbundance(), 1);
- EXPECT_EQ(p3.particleType(), Constants::ParticleType);
+ EXPECT_EQ(p3.particleType(), "Particle");
EXPECT_FALSE(p3.particle3DBlend(0u));
// Test copy assignment operator
@@ -106,7 +106,7 @@ TEST_F(TestRealSpaceBuilderUtils, test_Particle3DContainer)
EXPECT_EQ(p4.containerSize(), 1u);
EXPECT_EQ(p4.cumulativeAbundance(), 1);
- EXPECT_EQ(p4.particleType(), Constants::ParticleType);
+ EXPECT_EQ(p4.particleType(), "Particle");
EXPECT_FALSE(p4.particle3DBlend(0u));
// Add particle to RealSpaceModel by first creating a unique instance of it and then
@@ -132,7 +132,7 @@ TEST_F(TestRealSpaceBuilderUtils, test_Particle3DContainer)
// Test the contents of the Particle3DContainer being moved-to
EXPECT_EQ(p5.containerSize(), 1u);
EXPECT_EQ(p5.cumulativeAbundance(), 1);
- EXPECT_EQ(p5.particleType(), Constants::ParticleType);
+ EXPECT_EQ(p5.particleType(), "Particle");
EXPECT_FALSE(p5.particle3DBlend(0u));
auto p5_unique = p5.createParticle(0);
@@ -146,7 +146,7 @@ TEST_F(TestRealSpaceBuilderUtils, test_Particle3DContainer)
EXPECT_EQ(p6.containerSize(), 1u);
EXPECT_EQ(p6.cumulativeAbundance(), 1);
- EXPECT_EQ(p6.particleType(), Constants::ParticleType);
+ EXPECT_EQ(p6.particleType(), "Particle");
EXPECT_FALSE(p6.particle3DBlend(0u));
auto p6_unique = p6.createParticle(0);
@@ -162,7 +162,7 @@ TEST_F(TestRealSpaceBuilderUtils, test_Particle3DContainer)
EXPECT_EQ(p7.containerSize(), 1u);
EXPECT_EQ(p7.cumulativeAbundance(), 1);
- EXPECT_EQ(p7.particleType(), Constants::ParticleType);
+ EXPECT_EQ(p7.particleType(), "Particle");
EXPECT_FALSE(p7.particle3DBlend(0u));
auto p7_unique = p7.createParticle(0);
@@ -176,16 +176,16 @@ TEST_F(TestRealSpaceBuilderUtils, test_singleParticle3DContainer)
ApplicationModels models;
SampleModel* sampleModel = models.sampleModel();
- auto particleItem = sampleModel->insertNewItem(Constants::ParticleType);
+ auto particleItem = sampleModel->insertNewItem("Particle");
EXPECT_EQ(particleItem->getItemValue(ParticleItem::P_ABUNDANCE).toDouble(), 1.0);
EXPECT_EQ(particleItem->getGroupItem(ParticleItem::P_FORM_FACTOR)->modelType(),
- Constants::CylinderType);
+ "Cylinder");
particleItem->setItemValue(ParticleItem::P_ABUNDANCE, 8.0);
EXPECT_EQ(particleItem->getItemValue(ParticleItem::P_ABUNDANCE).toDouble(), 8.0);
- particleItem->setGroupProperty(ParticleItem::P_FORM_FACTOR, Constants::BoxType);
+ particleItem->setGroupProperty(ParticleItem::P_FORM_FACTOR, "Box");
EXPECT_EQ(particleItem->getGroupItem(ParticleItem::P_FORM_FACTOR)->modelType(),
- Constants::BoxType);
+ "Box");
// Create a 3D particle from particleItem and associate it to a Particle3DContainer object
auto pItem = dynamic_cast<const ParticleItem*>(particleItem);
@@ -194,7 +194,7 @@ TEST_F(TestRealSpaceBuilderUtils, test_singleParticle3DContainer)
EXPECT_EQ(singleParticle3DContainer.containerSize(), 1u);
EXPECT_EQ(singleParticle3DContainer.cumulativeAbundance(), 1);
- EXPECT_EQ(singleParticle3DContainer.particleType(), Constants::ParticleType);
+ EXPECT_EQ(singleParticle3DContainer.particleType(), "Particle");
EXPECT_FALSE(singleParticle3DContainer.particle3DBlend(0u));
}
@@ -204,11 +204,11 @@ TEST_F(TestRealSpaceBuilderUtils, test_particle3DContainerVector)
SampleModel* sampleModel = models.sampleModel();
auto layout = dynamic_cast<ParticleLayoutItem*>(
- sampleModel->insertNewItem(Constants::ParticleLayoutType));
+ sampleModel->insertNewItem("ParticleLayout"));
- auto particle1 = sampleModel->insertNewItem(Constants::ParticleType);
- auto particle2 = sampleModel->insertNewItem(Constants::ParticleType);
- auto particle3 = sampleModel->insertNewItem(Constants::ParticleType);
+ auto particle1 = sampleModel->insertNewItem("Particle");
+ auto particle2 = sampleModel->insertNewItem("Particle");
+ auto particle3 = sampleModel->insertNewItem("Particle");
sampleModel->moveItem(particle1, layout, -1, ParticleLayoutItem::T_PARTICLES);
sampleModel->moveItem(particle2, layout, -1, ParticleLayoutItem::T_PARTICLES);
@@ -221,9 +221,9 @@ TEST_F(TestRealSpaceBuilderUtils, test_particle3DContainerVector)
double total_abundance = RealSpaceBuilderUtils::computeCumulativeAbundances(*layout).last();
EXPECT_EQ(total_abundance, 10.0);
- particle1->setGroupProperty(ParticleItem::P_FORM_FACTOR, Constants::BoxType);
- particle2->setGroupProperty(ParticleItem::P_FORM_FACTOR, Constants::ConeType);
- particle3->setGroupProperty(ParticleItem::P_FORM_FACTOR, Constants::PyramidType);
+ particle1->setGroupProperty(ParticleItem::P_FORM_FACTOR, "Box");
+ particle2->setGroupProperty(ParticleItem::P_FORM_FACTOR, "Cone");
+ particle3->setGroupProperty(ParticleItem::P_FORM_FACTOR, "Pyramid");
auto particle3DContainer_vector = RealSpaceBuilderUtils::particle3DContainerVector(*layout);
@@ -231,15 +231,15 @@ TEST_F(TestRealSpaceBuilderUtils, test_particle3DContainerVector)
EXPECT_EQ(particle3DContainer_vector.at(0).containerSize(), 1u);
EXPECT_EQ(particle3DContainer_vector.at(0).cumulativeAbundance(), 0.5);
- EXPECT_EQ(particle3DContainer_vector.at(0).particleType(), Constants::ParticleType);
+ EXPECT_EQ(particle3DContainer_vector.at(0).particleType(), "Particle");
EXPECT_EQ(particle3DContainer_vector.at(1).containerSize(), 1u);
EXPECT_EQ(particle3DContainer_vector.at(1).cumulativeAbundance(), 0.8);
- EXPECT_EQ(particle3DContainer_vector.at(1).particleType(), Constants::ParticleType);
+ EXPECT_EQ(particle3DContainer_vector.at(1).particleType(), "Particle");
EXPECT_EQ(particle3DContainer_vector.at(2).containerSize(), 1u);
EXPECT_EQ(particle3DContainer_vector.at(2).cumulativeAbundance(), 1.0);
- EXPECT_EQ(particle3DContainer_vector.at(2).particleType(), Constants::ParticleType);
+ EXPECT_EQ(particle3DContainer_vector.at(2).particleType(), "Particle");
}
#endif // TESTREALSPACEBUILDERUTILS_H
diff --git a/Tests/UnitTests/GUI/TestSavingSpecularData.cpp b/Tests/UnitTests/GUI/TestSavingSpecularData.cpp
index 8583ac1f7ba5d79abd20b704f2f851f91e0e2c1b..76432e88efad986782fdbe1e0dd45adaa2356685 100644
--- a/Tests/UnitTests/GUI/TestSavingSpecularData.cpp
+++ b/Tests/UnitTests/GUI/TestSavingSpecularData.cpp
@@ -41,15 +41,15 @@ TestSavingSpecularData::TestSavingSpecularData()
SpecularInstrumentItem* TestSavingSpecularData::createSpecularInstrument(ApplicationModels& models)
{
return dynamic_cast<SpecularInstrumentItem*>(
- models.instrumentModel()->insertNewItem(Constants::SpecularInstrumentType));
+ models.instrumentModel()->insertNewItem("SpecularInstrument"));
}
PointwiseAxisItem* TestSavingSpecularData::createPointwiseAxisItem(SessionModel& model)
{
auto instrument_item = dynamic_cast<SpecularInstrumentItem*>(
- model.insertNewItem(Constants::SpecularInstrumentType));
+ model.insertNewItem("SpecularInstrument"));
return dynamic_cast<PointwiseAxisItem*>(
- getAxisGroup(instrument_item)->getChildOfType(Constants::PointwiseAxisType));
+ getAxisGroup(instrument_item)->getChildOfType("PointwiseAxis"));
}
GroupItem* TestSavingSpecularData::getAxisGroup(SpecularInstrumentItem* instrument)
@@ -85,11 +85,11 @@ TEST_F(TestSavingSpecularData, test_SpecularInsturment)
// explicitly switching to pointwise axis item
auto axis_group = getAxisGroup(instrument);
- axis_group->setCurrentType(Constants::PointwiseAxisType);
+ axis_group->setCurrentType("PointwiseAxis");
EXPECT_EQ(models.instrumentModel()->nonXMLData().size(), 1);
// hiding pointwise axis item back
- axis_group->setCurrentType(Constants::BasicAxisType);
+ axis_group->setCurrentType("BasicAxis");
EXPECT_EQ(models.instrumentModel()->nonXMLData().size(), 1);
// checking data items of OutputDataIOService
@@ -106,20 +106,20 @@ TEST_F(TestSavingSpecularData, test_InstrumentInJobItem)
ApplicationModels models;
// adding JobItem
- SessionItem* jobItem = models.jobModel()->insertNewItem(Constants::JobItemType);
+ SessionItem* jobItem = models.jobModel()->insertNewItem("JobItem");
SessionItem* dataItem = models.jobModel()->insertNewItem(
- Constants::IntensityDataType, jobItem->index(), -1, JobItem::T_OUTPUT);
+ "IntensityData", jobItem->index(), -1, JobItem::T_OUTPUT);
EXPECT_EQ(models.jobModel()->nonXMLData().size(), 1);
// adding instrument
auto instrument = dynamic_cast<SpecularInstrumentItem*>(models.jobModel()->insertNewItem(
- Constants::SpecularInstrumentType, jobItem->index(), -1, JobItem::T_INSTRUMENT));
+ "SpecularInstrument", jobItem->index(), -1, JobItem::T_INSTRUMENT));
// instrument contains hidden pointwise axis item
EXPECT_EQ(models.jobModel()->nonXMLData().size(), 2);
// explicitly switching to pointwise axis item
auto axis_group = getAxisGroup(instrument);
- axis_group->setCurrentType(Constants::PointwiseAxisType);
+ axis_group->setCurrentType("PointwiseAxis");
EXPECT_EQ(models.jobModel()->nonXMLData().size(), 2);
OutputDataIOService service(&models);
@@ -130,7 +130,7 @@ TEST_F(TestSavingSpecularData, test_InstrumentInJobItem)
EXPECT_EQ(dataItems.indexOf(dataItem), 0);
// hiding pointwise axis, should be saved anyway
- axis_group->setCurrentType(Constants::BasicAxisType);
+ axis_group->setCurrentType("BasicAxis");
EXPECT_EQ(models.jobModel()->nonXMLData().size(), 2);
EXPECT_EQ(service.nonXMLItems().size(), 2);
dataItems = models.nonXMLData();
@@ -150,7 +150,7 @@ TEST_F(TestSavingSpecularData, test_setLastModified)
EXPECT_FALSE(info.wasModifiedSinceLastSave());
QTest::qSleep(nap_time);
- item->init(*m_axis.get(), Constants::UnitsDegrees);
+ item->init(*m_axis.get(), "Degrees");
EXPECT_TRUE(info.wasModifiedSinceLastSave());
info = OutputDataSaveInfo::createSaved(item);
@@ -163,7 +163,7 @@ TEST_F(TestSavingSpecularData, test_DirHistory)
{
SessionModel model("TempModel");
auto item1 = createPointwiseAxisItem(model);
- item1->init(*m_axis, Constants::UnitsDegrees);
+ item1->init(*m_axis, "Degrees");
auto item2 = createPointwiseAxisItem(model);
@@ -187,7 +187,7 @@ TEST_F(TestSavingSpecularData, test_DirHistory)
// Modifying item
QTest::qSleep(10);
- item1->init(*m_axis, Constants::UnitsDegrees);
+ item1->init(*m_axis, "Degrees");
EXPECT_TRUE(history.wasModifiedSinceLastSave(item1));
}
@@ -206,14 +206,14 @@ TEST_F(TestSavingSpecularData, test_OutputDataIOService)
auto axis_group1 = getAxisGroup(instrument1);
auto pointwise_axis_item1 =
- dynamic_cast<PointwiseAxisItem*>(axis_group1->getChildOfType(Constants::PointwiseAxisType));
- pointwise_axis_item1->init(*m_axis, Constants::UnitsDegrees);
+ dynamic_cast<PointwiseAxisItem*>(axis_group1->getChildOfType("PointwiseAxis"));
+ pointwise_axis_item1->init(*m_axis, "Degrees");
auto axis_group2 = getAxisGroup(instrument2);
auto pointwise_axis_item2 =
- dynamic_cast<PointwiseAxisItem*>(axis_group2->getChildOfType(Constants::PointwiseAxisType));
+ dynamic_cast<PointwiseAxisItem*>(axis_group2->getChildOfType("PointwiseAxis"));
PointwiseAxis tmp("y", std::vector<double>{1.0, 2.0, 3.0});
- pointwise_axis_item2->init(tmp, Constants::UnitsRadians);
+ pointwise_axis_item2->init(tmp, "Radians");
// Saving first time
OutputDataIOService service(&models);
@@ -233,7 +233,7 @@ TEST_F(TestSavingSpecularData, test_OutputDataIOService)
// Modifying data and saving the project.
PointwiseAxis tmp2("z", std::vector<double>{2.0, 3.0, 4.0});
- pointwise_axis_item2->init(tmp2, Constants::UnitsRadians);
+ pointwise_axis_item2->init(tmp2, "Radians");
service.save(projectDir);
QTest::qSleep(10);
@@ -264,16 +264,16 @@ TEST_F(TestSavingSpecularData, test_CopyInstrumentToJobItem)
auto instrument = createSpecularInstrument(models);
auto axis_group = getAxisGroup(instrument);
auto pointwise_axis_item =
- dynamic_cast<PointwiseAxisItem*>(axis_group->getChildOfType(Constants::PointwiseAxisType));
- pointwise_axis_item->init(*m_axis, Constants::UnitsQyQz);
+ dynamic_cast<PointwiseAxisItem*>(axis_group->getChildOfType("PointwiseAxis"));
+ pointwise_axis_item->init(*m_axis, "q-space");
// adding JobItem and copying instrument
- auto jobItem = dynamic_cast<JobItem*>(models.jobModel()->insertNewItem(Constants::JobItemType));
+ auto jobItem = dynamic_cast<JobItem*>(models.jobModel()->insertNewItem("JobItem"));
JobModelFunctions::setupJobItemInstrument(jobItem, instrument);
auto job_instrument =
dynamic_cast<SpecularInstrumentItem*>(jobItem->getItem(JobItem::T_INSTRUMENT));
auto job_axis_item = dynamic_cast<PointwiseAxisItem*>(
- getAxisGroup(job_instrument)->getChildOfType(Constants::PointwiseAxisType));
+ getAxisGroup(job_instrument)->getChildOfType("PointwiseAxis"));
// checking filenames
EXPECT_EQ(pointwise_axis_item->fileName(),
diff --git a/Tests/UnitTests/GUI/TestSessionItemController.cpp b/Tests/UnitTests/GUI/TestSessionItemController.cpp
index 98748ba1413e6ed336d1150e9edbb379d3f9fd0d..7e28d437721f8e170ce962f49680a536bd6d159e 100644
--- a/Tests/UnitTests/GUI/TestSessionItemController.cpp
+++ b/Tests/UnitTests/GUI/TestSessionItemController.cpp
@@ -40,7 +40,7 @@ TEST_F(TestSessionItemController, test_setItem)
TestListener listener;
TestObject object(&listener);
SessionModel model("TestModel");
- SessionItem* item = model.insertNewItem(Constants::BasicAxisType);
+ SessionItem* item = model.insertNewItem("BasicAxis");
object.setItem(item);
EXPECT_EQ(object.currentItem(), item);
@@ -56,7 +56,7 @@ TEST_F(TestSessionItemController, test_setItemAndSubscribeItem)
TestListener listener;
TestObject object(&listener);
SessionModel model("TestModel");
- SessionItem* item = model.insertNewItem(Constants::BasicAxisType);
+ SessionItem* item = model.insertNewItem("BasicAxis");
object.setItem(item);
object.setVisible(true);
@@ -73,7 +73,7 @@ TEST_F(TestSessionItemController, test_onPropertyChange)
TestListener listener;
TestObject object(&listener);
SessionModel model("TestModel");
- SessionItem* item = model.insertNewItem(Constants::BasicAxisType);
+ SessionItem* item = model.insertNewItem("BasicAxis");
object.setItem(item);
EXPECT_EQ(object.currentItem(), item);
@@ -120,7 +120,7 @@ TEST_F(TestSessionItemController, test_onItemDestroyWidgetVisible)
TestListener listener;
TestObject object(&listener);
SessionModel model("TestModel");
- SessionItem* item = model.insertNewItem(Constants::BasicAxisType);
+ SessionItem* item = model.insertNewItem("BasicAxis");
object.setItem(item);
object.setVisible(true);
@@ -146,7 +146,7 @@ TEST_F(TestSessionItemController, test_onItemDestroyWidgetHidden)
TestListener listener;
TestObject object(&listener);
SessionModel model("TestModel");
- SessionItem* item = model.insertNewItem(Constants::BasicAxisType);
+ SessionItem* item = model.insertNewItem("BasicAxis");
object.setItem(item);
object.setVisible(true);
@@ -179,8 +179,8 @@ TEST_F(TestSessionItemController, test_onTwoItems)
TestListener listener;
TestObject object(&listener);
SessionModel model("TestModel");
- SessionItem* item1 = model.insertNewItem(Constants::BasicAxisType);
- SessionItem* item2 = model.insertNewItem(Constants::BasicAxisType);
+ SessionItem* item1 = model.insertNewItem("BasicAxis");
+ SessionItem* item2 = model.insertNewItem("BasicAxis");
object.setItem(item1);
EXPECT_EQ(object.currentItem(), item1);
@@ -213,8 +213,8 @@ TEST_F(TestSessionItemController, test_onTwoItemsWhenHidden)
TestListener listener;
TestObject object(&listener);
SessionModel model("TestModel");
- SessionItem* item1 = model.insertNewItem(Constants::BasicAxisType);
- SessionItem* item2 = model.insertNewItem(Constants::BasicAxisType);
+ SessionItem* item1 = model.insertNewItem("BasicAxis");
+ SessionItem* item2 = model.insertNewItem("BasicAxis");
object.setVisible(false);
@@ -246,7 +246,7 @@ TEST_F(TestSessionItemController, test_deleteWidget)
TestListener listener;
TestObject* object = new TestObject(&listener);
SessionModel model("TestModel");
- SessionItem* item = model.insertNewItem(Constants::BasicAxisType);
+ SessionItem* item = model.insertNewItem("BasicAxis");
object->setItem(item);
object->setVisible(true);
diff --git a/Tests/UnitTests/GUI/TestSessionItemTags.cpp b/Tests/UnitTests/GUI/TestSessionItemTags.cpp
index d19f70e512b4a1267e414c89c60eae909a00c469..1729d6147c45cedba36f343eca1322fe79c70387 100644
--- a/Tests/UnitTests/GUI/TestSessionItemTags.cpp
+++ b/Tests/UnitTests/GUI/TestSessionItemTags.cpp
@@ -1,5 +1,4 @@
#include "GUI/coregui/Models/SessionItemTags.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/utils/GUIHelpers.h"
#include "Tests/UnitTests/utilities/google_test.h"
@@ -19,20 +18,20 @@ TEST_F(TestSessionItemTags, registerTag)
SessionItemTags tags;
// registering tag
- EXPECT_TRUE(tags.registerTag("tag1", 0, 1, QStringList() << Constants::ParticleType));
+ EXPECT_TRUE(tags.registerTag("tag1", 0, 1, QStringList() << "Particle"));
EXPECT_TRUE(tags.isValid("tag1"));
- EXPECT_TRUE(tags.isValid("tag1", Constants::ParticleType));
+ EXPECT_TRUE(tags.isValid("tag1", "Particle"));
EXPECT_FALSE(tags.isValid("tag1", "wrongModelType"));
- QStringList expected = QStringList() << Constants::ParticleType;
+ QStringList expected = QStringList() << "Particle";
EXPECT_EQ(tags.modelTypesForTag("tag1"), expected);
// registering tag twice
- EXPECT_FALSE(tags.registerTag("tag1", 0, 1, QStringList() << Constants::ParticleType));
+ EXPECT_FALSE(tags.registerTag("tag1", 0, 1, QStringList() << "Particle"));
// registering another tag
EXPECT_TRUE(tags.registerTag("tag2", 0, 1,
- QStringList() << Constants::ParticleType << Constants::LayerType));
- expected = QStringList() << Constants::ParticleType << Constants::LayerType;
+ QStringList() << "Particle" << "Layer"));
+ expected = QStringList() << "Particle" << "Layer";
EXPECT_EQ(tags.modelTypesForTag("tag2"), expected);
}
@@ -40,7 +39,7 @@ TEST_F(TestSessionItemTags, modelTypesForTag)
{
SessionItemTags tags;
- QStringList expected = QStringList() << Constants::ParticleType << Constants::LayerType;
+ QStringList expected = QStringList() << "Particle" << "Layer";
EXPECT_TRUE(tags.registerTag("tag1", 0, 1, expected));
EXPECT_EQ(tags.modelTypesForTag("tag1"), expected);
@@ -56,12 +55,12 @@ TEST_F(TestSessionItemTags, tagStartIndex)
SessionItemTags tags;
// registering tags
- EXPECT_TRUE(tags.registerTag("tag1", 0, 2, QStringList() << Constants::ParticleType));
+ EXPECT_TRUE(tags.registerTag("tag1", 0, 2, QStringList() << "Particle"));
EXPECT_EQ(tags.childCount("tag1"), 0);
EXPECT_EQ(tags.tagStartIndex("tag1"), 0);
EXPECT_TRUE(tags.registerTag("tag2", 0, 1,
- QStringList() << Constants::ParticleType << Constants::LayerType));
+ QStringList() << "Particle" << "Layer"));
EXPECT_EQ(tags.childCount("tag2"), 0);
EXPECT_EQ(tags.tagStartIndex("tag2"), 0);
@@ -92,8 +91,8 @@ TEST_F(TestSessionItemTags, tagStartIndex)
TEST_F(TestSessionItemTags, indexFromTagRow)
{
SessionItemTags tags;
- tags.registerTag("tag1", 0, -1, QStringList() << Constants::ParticleType);
- tags.registerTag("tag2", 0, 2, QStringList() << Constants::ParticleType);
+ tags.registerTag("tag1", 0, -1, QStringList() << "Particle");
+ tags.registerTag("tag2", 0, 2, QStringList() << "Particle");
tags.addChild("tag1"); // index=0, row=0
tags.addChild("tag1"); // index=1, row=1
@@ -114,8 +113,8 @@ TEST_F(TestSessionItemTags, indexFromTagRow)
TEST_F(TestSessionItemTags, tagFromIndex)
{
SessionItemTags tags;
- tags.registerTag("tag1", 0, -1, QStringList() << Constants::ParticleType);
- tags.registerTag("tag2", 0, 2, QStringList() << Constants::ParticleType);
+ tags.registerTag("tag1", 0, -1, QStringList() << "Particle");
+ tags.registerTag("tag2", 0, 2, QStringList() << "Particle");
tags.addChild("tag1"); // index=0
tags.addChild("tag1"); // index=1
@@ -138,8 +137,8 @@ TEST_F(TestSessionItemTags, tagFromIndex)
TEST_F(TestSessionItemTags, insertIndexFromTagRow)
{
SessionItemTags tags;
- tags.registerTag("tag1", 0, -1, QStringList() << Constants::ParticleType);
- tags.registerTag("tag2", 0, 2, QStringList() << Constants::ParticleType);
+ tags.registerTag("tag1", 0, -1, QStringList() << "Particle");
+ tags.registerTag("tag2", 0, 2, QStringList() << "Particle");
tags.addChild("tag1"); // index=0, row=0
tags.addChild("tag1"); // index=1, row=1
diff --git a/Tests/UnitTests/GUI/TestSessionItemUtils.cpp b/Tests/UnitTests/GUI/TestSessionItemUtils.cpp
index 9b4426a4a593128c65dd28abf31b9f9ebac35f59..8cdbad1673fb3c1cd6534289bdadec3f61d7e476 100644
--- a/Tests/UnitTests/GUI/TestSessionItemUtils.cpp
+++ b/Tests/UnitTests/GUI/TestSessionItemUtils.cpp
@@ -3,7 +3,6 @@
#include "GUI/coregui/Models/SessionItemUtils.h"
#include "GUI/coregui/Models/SessionModel.h"
#include "GUI/coregui/Models/VectorItem.h"
-#include "GUI/coregui/Models/item_constants.h"
#include "GUI/coregui/Views/MaterialEditor/ExternalProperty.h"
#include "Tests/UnitTests/utilities/google_test.h"
@@ -18,9 +17,9 @@ TEST_F(TestSessionItemUtils, test_ParentVisibleRow)
SessionModel model("TestModel");
// 3 property items in root, all visible
- auto item1 = model.insertNewItem(Constants::PropertyType);
- auto item2 = model.insertNewItem(Constants::PropertyType);
- auto item3 = model.insertNewItem(Constants::PropertyType);
+ auto item1 = model.insertNewItem("Property");
+ auto item2 = model.insertNewItem("Property");
+ auto item3 = model.insertNewItem("Property");
EXPECT_EQ(SessionItemUtils::ParentVisibleRow(*item1), 0);
EXPECT_EQ(SessionItemUtils::ParentVisibleRow(*item2), 1);
EXPECT_EQ(SessionItemUtils::ParentVisibleRow(*item3), 2);
@@ -32,8 +31,8 @@ TEST_F(TestSessionItemUtils, test_ParentVisibleRow)
EXPECT_EQ(SessionItemUtils::ParentVisibleRow(*item3), 1);
// two more items
- auto item4 = model.insertNewItem(Constants::PropertyType);
- auto item5 = model.insertNewItem(Constants::PropertyType);
+ auto item4 = model.insertNewItem("Property");
+ auto item5 = model.insertNewItem("Property");
item5->setVisible(false);
EXPECT_EQ(SessionItemUtils::ParentVisibleRow(*item1), 0);
EXPECT_EQ(SessionItemUtils::ParentVisibleRow(*item2), -1);
@@ -42,7 +41,7 @@ TEST_F(TestSessionItemUtils, test_ParentVisibleRow)
EXPECT_EQ(SessionItemUtils::ParentVisibleRow(*item5), -1);
// adding vector item
- SessionItem* vector = model.insertNewItem(Constants::VectorType);
+ SessionItem* vector = model.insertNewItem("Vector");
auto x = vector->getItem(VectorItem::P_X);
auto y = vector->getItem(VectorItem::P_Y);
auto z = vector->getItem(VectorItem::P_Z);
diff --git a/Tests/UnitTests/GUI/TestSessionModel.cpp b/Tests/UnitTests/GUI/TestSessionModel.cpp
index 1cd8555750c2d1f218c1821ac6a4fdbb5aab5e93..d25e30ffc13883acc7a68522eb6876c2d807788b 100644
--- a/Tests/UnitTests/GUI/TestSessionModel.cpp
+++ b/Tests/UnitTests/GUI/TestSessionModel.cpp
@@ -20,7 +20,7 @@ class TestSessionModel : public ::testing::Test
TEST_F(TestSessionModel, setData)
{
SessionModel model("TestModel");
- auto item = model.insertNewItem(Constants::PropertyType);
+ auto item = model.insertNewItem("Property");
QSignalSpy spy(&model, &SessionModel::dataChanged);
@@ -47,10 +47,10 @@ TEST_F(TestSessionModel, SampleModelCopy)
std::unique_ptr<MaterialModel> P_materialModel(new MaterialModel());
SampleModel model1;
- SessionItem* multilayer = model1.insertNewItem(Constants::MultiLayerType);
+ SessionItem* multilayer = model1.insertNewItem("MultiLayer");
multilayer->setItemName("multilayer");
- model1.insertNewItem(Constants::LayerType, model1.indexOfItem(multilayer));
- SessionItem* multilayer2 = model1.insertNewItem(Constants::MultiLayerType);
+ model1.insertNewItem("Layer", model1.indexOfItem(multilayer));
+ SessionItem* multilayer2 = model1.insertNewItem("MultiLayer");
multilayer2->setItemName("multilayer2");
QString buffer1;
@@ -70,11 +70,11 @@ TEST_F(TestSessionModel, SampleModelPartialCopy)
std::unique_ptr<MaterialModel> P_materialModel(new MaterialModel());
SampleModel model1;
- SessionItem* multilayer1 = model1.insertNewItem(Constants::MultiLayerType);
+ SessionItem* multilayer1 = model1.insertNewItem("MultiLayer");
multilayer1->setItemName("multilayer1");
- model1.insertNewItem(Constants::LayerType, model1.indexOfItem(multilayer1));
+ model1.insertNewItem("Layer", model1.indexOfItem(multilayer1));
- SessionItem* multilayer2 = model1.insertNewItem(Constants::MultiLayerType);
+ SessionItem* multilayer2 = model1.insertNewItem("MultiLayer");
multilayer2->setItemName("multilayer2");
std::unique_ptr<SampleModel> model2(model1.createCopy(multilayer1));
@@ -87,10 +87,10 @@ TEST_F(TestSessionModel, SampleModelPartialCopy)
TEST_F(TestSessionModel, InstrumentModelCopy)
{
InstrumentModel model1;
- SessionItem* instrument1 = model1.insertNewItem(Constants::GISASInstrumentType);
+ SessionItem* instrument1 = model1.insertNewItem("GISASInstrument");
instrument1->setItemName("instrument1");
- SessionItem* instrument2 = model1.insertNewItem(Constants::GISASInstrumentType);
+ SessionItem* instrument2 = model1.insertNewItem("GISASInstrument");
instrument2->setItemName("instrument2");
QString buffer1;
@@ -108,10 +108,10 @@ TEST_F(TestSessionModel, InstrumentModelCopy)
TEST_F(TestSessionModel, InstrumentModelPartialCopy)
{
InstrumentModel model1;
- SessionItem* instrument1 = model1.insertNewItem(Constants::GISASInstrumentType);
+ SessionItem* instrument1 = model1.insertNewItem("GISASInstrument");
instrument1->setItemName("instrument1");
- SessionItem* instrument2 = model1.insertNewItem(Constants::GISASInstrumentType);
+ SessionItem* instrument2 = model1.insertNewItem("GISASInstrument");
instrument2->setItemName("instrument2");
std::unique_ptr<InstrumentModel> model2(model1.createCopy(instrument2));
@@ -127,16 +127,16 @@ TEST_F(TestSessionModel, copyItem)
std::unique_ptr<MaterialModel> P_materialModel(new MaterialModel());
SampleModel sampleModel;
- SessionItem* multilayer1 = sampleModel.insertNewItem(Constants::MultiLayerType);
+ SessionItem* multilayer1 = sampleModel.insertNewItem("MultiLayer");
multilayer1->setItemName("multilayer1");
- sampleModel.insertNewItem(Constants::LayerType, sampleModel.indexOfItem(multilayer1));
+ sampleModel.insertNewItem("Layer", sampleModel.indexOfItem(multilayer1));
InstrumentModel instrumentModel;
- SessionItem* instrument1 = instrumentModel.insertNewItem(Constants::GISASInstrumentType);
+ SessionItem* instrument1 = instrumentModel.insertNewItem("GISASInstrument");
instrument1->setItemName("instrument1");
JobModel jobModel;
- SessionItem* jobItem = jobModel.insertNewItem(Constants::JobItemType);
+ SessionItem* jobItem = jobModel.insertNewItem("JobItem");
jobModel.copyItem(multilayer1, jobItem, JobItem::T_SAMPLE);
EXPECT_EQ(jobItem->sessionItemTags()->childCount(JobItem::T_SAMPLE), 1);
@@ -148,8 +148,8 @@ TEST_F(TestSessionModel, copyItem)
TEST_F(TestSessionModel, moveItemFromRoot)
{
SessionModel model("TestModel");
- auto poly = model.insertNewItem(Constants::PolygonMaskType);
- auto point = model.insertNewItem(Constants::PolygonPointType);
+ auto poly = model.insertNewItem("PolygonMask");
+ auto point = model.insertNewItem("PolygonPoint");
EXPECT_EQ(poly->parent(), model.rootItem());
EXPECT_EQ(point->parent(), model.rootItem());
@@ -173,10 +173,10 @@ TEST_F(TestSessionModel, moveItemFromRoot)
TEST_F(TestSessionModel, moveBetweenParents)
{
SessionModel model("TestModel");
- auto poly1 = model.insertNewItem(Constants::PolygonMaskType);
- auto point11 = model.insertNewItem(Constants::PolygonPointType, model.indexOfItem(poly1));
- auto point12 = model.insertNewItem(Constants::PolygonPointType, model.indexOfItem(poly1));
- auto poly2 = model.insertNewItem(Constants::PolygonMaskType);
+ auto poly1 = model.insertNewItem("PolygonMask");
+ auto point11 = model.insertNewItem("PolygonPoint", model.indexOfItem(poly1));
+ auto point12 = model.insertNewItem("PolygonPoint", model.indexOfItem(poly1));
+ auto poly2 = model.insertNewItem("PolygonMask");
EXPECT_EQ(point11->parent(), poly1);
EXPECT_EQ(point12->parent(), poly1);
@@ -191,12 +191,12 @@ TEST_F(TestSessionModel, moveBetweenParents)
TEST_F(TestSessionModel, moveWithinSameParent)
{
SessionModel model("TestModel");
- auto poly = model.insertNewItem(Constants::PolygonMaskType);
- auto pA = model.insertNewItem(Constants::PolygonPointType, model.indexOfItem(poly));
- auto pB = model.insertNewItem(Constants::PolygonPointType, model.indexOfItem(poly));
- auto pC = model.insertNewItem(Constants::PolygonPointType, model.indexOfItem(poly));
- auto pD = model.insertNewItem(Constants::PolygonPointType, model.indexOfItem(poly));
- auto pE = model.insertNewItem(Constants::PolygonPointType, model.indexOfItem(poly));
+ auto poly = model.insertNewItem("PolygonMask");
+ auto pA = model.insertNewItem("PolygonPoint", model.indexOfItem(poly));
+ auto pB = model.insertNewItem("PolygonPoint", model.indexOfItem(poly));
+ auto pC = model.insertNewItem("PolygonPoint", model.indexOfItem(poly));
+ auto pD = model.insertNewItem("PolygonPoint", model.indexOfItem(poly));
+ auto pE = model.insertNewItem("PolygonPoint", model.indexOfItem(poly));
// 0 pA -> pA
// 1 pB -> pC
diff --git a/Tests/UnitTests/GUI/TestSessionXML.cpp b/Tests/UnitTests/GUI/TestSessionXML.cpp
index 22e3157169570ec43de1daee3db7a291ca9e50c7..04dc4312e1989ab456c4c2e3ea40010af2070638 100644
--- a/Tests/UnitTests/GUI/TestSessionXML.cpp
+++ b/Tests/UnitTests/GUI/TestSessionXML.cpp
@@ -35,7 +35,7 @@ TEST_F(TestSessionXML, test_sessionItem)
QString expected;
SessionModel source("TestModel");
- source.insertNewItem(Constants::PropertyType);
+ source.insertNewItem("Property");
expected = "<TestModel Name=\"DefaultName\">"
"<Item ModelType=\"Property\" Tag=\"rootTag\" DisplayName=\"Property\"/>"
@@ -47,7 +47,7 @@ TEST_F(TestSessionXML, test_sessionItem)
EXPECT_EQ(target.rowCount(QModelIndex()), 1);
SessionItem* newItem = target.itemForIndex(target.index(0, 0, QModelIndex()));
- EXPECT_EQ(newItem->modelType(), Constants::PropertyType);
+ EXPECT_EQ(newItem->modelType(), "Property");
EXPECT_EQ(newItem->displayName(), QString("Property"));
EXPECT_FALSE(newItem->value().isValid());
}
@@ -58,7 +58,7 @@ TEST_F(TestSessionXML, test_FullSphereItem)
{
// source model, to xml
SessionModel source("TestModel");
- SessionItem* sphere = source.insertNewItem(Constants::FullSphereType);
+ SessionItem* sphere = source.insertNewItem("FullSphere");
SessionItem* radius = sphere->getItem(FullSphereItem::P_RADIUS);
QString buffer = itemToXML(source.rootItem());
@@ -91,9 +91,9 @@ TEST_F(TestSessionXML, test_twoFullSphereItems)
{
// source model, to xml
SessionModel source("TestModel");
- SessionItem* sphere1 = source.insertNewItem(Constants::FullSphereType);
+ SessionItem* sphere1 = source.insertNewItem("FullSphere");
sphere1->setItemValue(FullSphereItem::P_RADIUS, 1.0);
- SessionItem* sphere2 = source.insertNewItem(Constants::FullSphereType);
+ SessionItem* sphere2 = source.insertNewItem("FullSphere");
sphere2->setItemValue(FullSphereItem::P_RADIUS, 2.0);
QString buffer = itemToXML(source.rootItem());
@@ -107,7 +107,7 @@ TEST_F(TestSessionXML, test_twoFullSphereItems)
TEST_F(TestSessionXML, test_emptyMultiLayer)
{
SessionModel source("TestModel");
- source.insertNewItem(Constants::MultiLayerType);
+ source.insertNewItem("MultiLayer");
QString buffer = itemToXML(source.rootItem());
SessionModel target("TestModel");
@@ -120,7 +120,7 @@ TEST_F(TestSessionXML, test_emptyMultiLayer)
TEST_F(TestSessionXML, test_Layer)
{
SessionModel source("TestModel");
- source.insertNewItem(Constants::LayerType);
+ source.insertNewItem("Layer");
QString buffer = itemToXML(source.rootItem());
SessionModel target("TestModel");
@@ -133,7 +133,7 @@ TEST_F(TestSessionXML, test_Layer)
TEST_F(TestSessionXML, test_Particle)
{
SessionModel source("TestModel");
- source.insertNewItem(Constants::ParticleType);
+ source.insertNewItem("Particle");
QString buffer = itemToXML(source.rootItem());
SessionModel target("TestModel");
@@ -146,9 +146,9 @@ TEST_F(TestSessionXML, test_Particle)
TEST_F(TestSessionXML, test_ParticleWithFF)
{
SessionModel source("TestModel");
- SessionItem* particle = source.insertNewItem(Constants::ParticleType);
+ SessionItem* particle = source.insertNewItem("Particle");
- particle->setGroupProperty(ParticleItem::P_FORM_FACTOR, Constants::AnisoPyramidType);
+ particle->setGroupProperty(ParticleItem::P_FORM_FACTOR, "AnisoPyramid");
QString buffer = itemToXML(source.rootItem());
SessionModel target("TestModel");
diff --git a/Tests/UnitTests/GUI/TestTranslations.cpp b/Tests/UnitTests/GUI/TestTranslations.cpp
index 354dc9f9cc9d871573db5af9ce08adbaa54fd621..384d78963803be790a811292e61f3bca645a9a0b 100644
--- a/Tests/UnitTests/GUI/TestTranslations.cpp
+++ b/Tests/UnitTests/GUI/TestTranslations.cpp
@@ -17,10 +17,10 @@ class TestTranslations : public ::testing::Test
TEST_F(TestTranslations, test_TranslatePosition)
{
SampleModel model;
- SessionItem* multilayer = model.insertNewItem(Constants::MultiLayerType);
- SessionItem* layer = model.insertNewItem(Constants::LayerType, multilayer->index());
- SessionItem* layout = model.insertNewItem(Constants::ParticleLayoutType, layer->index());
- SessionItem* particle = model.insertNewItem(Constants::ParticleType, layout->index());
+ SessionItem* multilayer = model.insertNewItem("MultiLayer");
+ SessionItem* layer = model.insertNewItem("Layer", multilayer->index());
+ SessionItem* layout = model.insertNewItem("ParticleLayout", layer->index());
+ SessionItem* particle = model.insertNewItem("Particle", layout->index());
SessionItem* positionItem = particle->getItem(ParticleItem::P_POSITION);
SessionItem* xItem = positionItem->getItem(VectorItem::P_X);
@@ -32,16 +32,16 @@ TEST_F(TestTranslations, test_TranslatePosition)
TEST_F(TestTranslations, test_TranslateRotation)
{
SampleModel model;
- SessionItem* multilayer = model.insertNewItem(Constants::MultiLayerType);
- SessionItem* layer = model.insertNewItem(Constants::LayerType, multilayer->index());
- SessionItem* layout = model.insertNewItem(Constants::ParticleLayoutType, layer->index());
- SessionItem* particle = model.insertNewItem(Constants::ParticleType, layout->index());
+ SessionItem* multilayer = model.insertNewItem("MultiLayer");
+ SessionItem* layer = model.insertNewItem("Layer", multilayer->index());
+ SessionItem* layout = model.insertNewItem("ParticleLayout", layer->index());
+ SessionItem* particle = model.insertNewItem("Particle", layout->index());
- SessionItem* transformation = model.insertNewItem(Constants::RotationType, particle->index(),
+ SessionItem* transformation = model.insertNewItem("Rotation", particle->index(),
-1, ParticleItem::T_TRANSFORMATION);
SessionItem* rotationItem =
- transformation->setGroupProperty(TransformationItem::P_ROT, Constants::XRotationType);
+ transformation->setGroupProperty(TransformationItem::P_ROT, "XRotation");
SessionItem* angleItem = rotationItem->getItem(XRotationItem::P_ANGLE);
EXPECT_EQ(ModelPath::itemPathTranslation(*angleItem, multilayer->parent()),
@@ -51,13 +51,13 @@ TEST_F(TestTranslations, test_TranslateRotation)
TEST_F(TestTranslations, test_BeamDistributionNone)
{
SampleModel model;
- SessionItem* instrument = model.insertNewItem(Constants::GISASInstrumentType);
+ SessionItem* instrument = model.insertNewItem("GISASInstrument");
SessionItem* beam = instrument->getItem(Instrument2DItem::P_BEAM);
SessionItem* wavelength = beam->getItem(BeamItem::P_WAVELENGTH);
SessionItem* distr = wavelength->getGroupItem(BeamDistributionItem::P_DISTRIBUTION);
- EXPECT_EQ(distr->modelType(), Constants::DistributionNoneType);
+ EXPECT_EQ(distr->modelType(), "DistributionNone");
SessionItem* value = distr->getItem(DistributionNoneItem::P_MEAN);
EXPECT_EQ(ModelPath::itemPathTranslation(*value, instrument->parent()),
diff --git a/Tests/UnitTests/GUI/test_utils.cpp b/Tests/UnitTests/GUI/test_utils.cpp
index 17b071f63c8e8c8b59ab1a72a5b38b45c95514a3..3c23f781f467d499498e2ee0b6014f41e46ade86 100644
--- a/Tests/UnitTests/GUI/test_utils.cpp
+++ b/Tests/UnitTests/GUI/test_utils.cpp
@@ -50,7 +50,7 @@ RealDataItem* TestUtils::createRealData(const QString& name, SessionModel& model
DIM n_dim)
{
RealDataItem* result =
- dynamic_cast<RealDataItem*>(model.insertNewItem(Constants::RealDataType));
+ dynamic_cast<RealDataItem*>(model.insertNewItem("RealData"));
result->setOutputData(createData(value, n_dim).release());
result->setItemValue(SessionItem::P_NAME, name);
return result;