GUI::Util Namespace Reference

Namespaces
	CoordName
	IO
	Provides utility methods for output data.
	Layout
	Utility functions to add/remove widgets to the layout on the fly. Taken from https://stackoverflow.com/questions/5395266/removing-widgets-from-qgridlayout.
	Path
	String
	Style
	Variant

Functions
template<typename T >
void	copyContents (const T *source, T *dest)
template<typename T >
QByteArray	createBackup (const T *t)
ScientificSpinBox *	createScientificSpinBox (QFormLayout *parentLayout, const DoubleDescriptor &d, std::function< void(double)> slot=nullptr)
	Create a label and a scientific spin box with the information found in a DoubleDescriptor and place them in a row in a form layout. More...
template<typename T >
QComboBox *	createSelectionCombo (QWidget *parent, const SelectionDescriptor< T > d, std::function< void(int)> slot=nullptr)
	Create a combo box with the information found in a selection descriptor. More...
DoubleSpinBox *	createSpinBox (QFormLayout *parentLayout, const DoubleDescriptor &d, std::function< void(double)> slot=nullptr)
	Create a label and a spin box with the information found in a DoubleDescriptor and place them in a row in a form layout. More...
QSpinBox *	createSpinBox (QFormLayout *parentLayout, const UIntDescriptor &d)
	Create a label and a spin box with the information found in a UIntDescriptor and place them in a row in a form layout. More...
QSpinBox *	createSpinBox (QWidget *parent, const UIntDescriptor &d, std::function< void(uint)> slot=nullptr)
	Create a spin box with the information found in a UIntDescriptor. More...
QString	labelWithUnit (const DoubleDescriptor &d)
	Create a label with an optional unit in brackets, both taken from the given descriptor. More...
QString	labelWithUnit (const QString &label, std::variant< QString, Unit > unit)
	Create a label with an optional unit in brackets. More...
template<typename T >
void	restoreBackup (T *t, const QByteArray &backup)

Function Documentation

copyContents()

template<typename T >

void GUI::Util::copyContents	(	const T *	source,
		T *	dest
	)

Definition at line 46 of file Backup.h.

{
    GUI::Util::restoreBackup(dest, GUI::Util::createBackup(source));
}

References createBackup(), and restoreBackup().

Referenced by InstrumentItem::createCopy(), and MultiLayerItem::initFrom().

Here is the call graph for this function:

createBackup()

template<typename T >

QByteArray GUI::Util::createBackup

(

const T *

t

)

Definition at line 24 of file Backup.h.

{
    QByteArray backup;
    QXmlStreamWriter w(&backup);
    w.writeStartElement("backup");
    Streamer s(&w);
    const_cast<T*>(t)->serialize(s);
    w.writeEndElement();
    return backup;
}

Referenced by CommandRemoveLayer::CommandRemoveLayer(), copyContents(), and MaterialInplaceForm::selectMaterial().

createScientificSpinBox()

ScientificSpinBox * GUI::Util::createScientificSpinBox	(	QFormLayout *	parentLayout,
		const DoubleDescriptor &	d,
		std::function< void(double)>	slot = nullptr
	)

Create a label and a scientific spin box with the information found in a DoubleDescriptor and place them in a row in a form layout.

The spin box will be fully initialized (tooltip, limits, current value, unit, size policy). Furthermore, the spin box will prohibit accidental changes by the mouse wheel. Otherwise it would be dangerous if the spin box is on a scrollable form - unintended and unnoticed changes would take place when just scrolling through the form.

No connections to update the descriptor will be established! Therefore changes in the spin box will not be notified to the descriptor. The additional (and optional) slot can be used to be notified about a value change.

Definition at line 82 of file WidgetUtils.cpp.

{
    auto* spinBox = new ScientificSpinBox(parentLayout->parentWidget());
    spinBox->setFocusPolicy(Qt::StrongFocus);
    GUI::View::EditUtil::configSpinbox(spinBox, d.decimals, d.limits);
    spinBox->setToolTip(d.tooltip);
    spinBox->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
    spinBox->setValue(d.get());
    parentLayout->addRow(labelWithUnit(d.label, d.unit) + ":", spinBox);
 
    if (slot)
        QObject::connect(spinBox, &ScientificSpinBox::valueChanged, [=](double v) { slot(v); });
 
    return spinBox;
}

References GUI::View::EditUtil::configSpinbox(), DoubleDescriptor::decimals, DoubleDescriptor::get, DoubleDescriptor::label, labelWithUnit(), DoubleDescriptor::limits, DoubleDescriptor::tooltip, DoubleDescriptor::unit, and ScientificSpinBox::valueChanged().

Referenced by DistributionSelector::createMeanSpinBox().

Here is the call graph for this function:

createSelectionCombo()

template<typename T >

QComboBox* GUI::Util::createSelectionCombo	(	QWidget *	parent,
		const SelectionDescriptor< T >	d,
		std::function< void(int)>	slot = nullptr
	)

Create a combo box with the information found in a selection descriptor.

The combo will be filled with the available options and will get the found tooltip. The current index will be set according to the current index in the selection. Furthermore, the combo box will prohibit accidental changes by the mouse wheel. Otherwise it would be dangerous if the combo is on a scrollable form - unintended and unnoticed changes would take place when just scrolling through the form.

Changes in the combobox will be notified to the SelectionDescriptor already. The additional (and optional) slot can be used to be notified about an already executed change.

Definition at line 45 of file WidgetUtils.h.

{
    auto* combo = new QComboBox(parent);
    combo->addItems(d.options);
    combo->setMaxCount(d.options.size());
    combo->setToolTip(d.tooltip);
    combo->setCurrentIndex(d.currentIndex());
    WheelEventEater::install(combo);
 
    QObject::connect(combo, qOverload<int>(&QComboBox::currentIndexChanged),
                     [=](int newIndex) { d.setCurrentIndex(newIndex); });
 
    if (slot)
        QObject::connect(combo, qOverload<int>(&QComboBox::currentIndexChanged),
                         [=](int newIndex) { slot(newIndex); });
 
    return combo;
}

References SelectionDescriptor< T >::currentIndex(), WheelEventEater::install(), SelectionDescriptor< T >::options, SelectionDescriptor< T >::setCurrentIndex(), and SelectionDescriptor< T >::tooltip.

Referenced by DetectorAlignmentEditor::DetectorAlignmentEditor(), DetectorEditor::DetectorEditor(), DistributionSelector::DistributionSelector(), EnvironmentEditor::EnvironmentEditor(), FootprintCorrectionEditor::FootprintCorrectionEditor(), ResolutionFunctionEditor::ResolutionFunctionEditor(), and MinimizerSettingsWidget::setItem().

Here is the call graph for this function:

createSpinBox() [1/3]

DoubleSpinBox * GUI::Util::createSpinBox	(	QFormLayout *	parentLayout,
		const DoubleDescriptor &	d,
		std::function< void(double)>	slot = nullptr
	)

Create a label and a spin box with the information found in a DoubleDescriptor and place them in a row in a form layout.

The spin box will be fully initialized (tooltip, limits, current value, unit, size policy). Furthermore, the spin box will prohibit accidental changes by the mouse wheel. Otherwise it would be dangerous if the spin box is on a scrollable form - unintended and unnoticed changes would take place when just scrolling through the form.

No connections to update the descriptor will be established! Therefore changes in the spin box will not be notified to the descriptor. The additional (and optional) slot can be used to be notified about a value change (the notified new value is in the base unit of the DoubleDescriptor).

Definition at line 47 of file WidgetUtils.cpp.

{
    auto* sb = new DoubleSpinBox(parentLayout->parentWidget(), d);
    parentLayout->addRow(labelWithUnit(d.label, d.unit) + ":", sb);
 
    if (slot)
        QObject::connect(sb, &DoubleSpinBox::baseValueChanged, [=](int v) { slot(v); });
 
    return sb;
}

References DoubleSpinBox::baseValueChanged(), DoubleDescriptor::label, labelWithUnit(), and DoubleDescriptor::unit.

Here is the call graph for this function:

createSpinBox() [2/3]

QSpinBox * GUI::Util::createSpinBox	(	QFormLayout *	parentLayout,
		const UIntDescriptor &	d
	)

Create a label and a spin box with the information found in a UIntDescriptor and place them in a row in a form layout.

The label will also contain the unit, if present. Regarding the spin box creation see the method above.

Definition at line 59 of file WidgetUtils.cpp.

{
    auto* sb = createSpinBox(parentLayout->parentWidget(), d);
    parentLayout->addRow(labelWithUnit(d.label, d.unit) + ":", sb);
    return sb;
}

References createSpinBox(), UIntDescriptor::label, labelWithUnit(), and UIntDescriptor::unit.

Here is the call graph for this function:

createSpinBox() [3/3]

QSpinBox * GUI::Util::createSpinBox	(	QWidget *	parent,
		const UIntDescriptor &	d,
		std::function< void(uint)>	slot = nullptr
	)

Create a spin box with the information found in a UIntDescriptor.

The spin box will be fully initialized (tooltip, limits, current value, size policy). Furthermore, the spin box will prohibit accidental changes by the mouse wheel. Otherwise it would be dangerous if the spin box is on a scrollable form - unintended and unnoticed changes would take place when just scrolling through the form.

No connections to update the descriptor will be established! Therefore changes in the spin box will not be notified to the descriptor. The additional (and optional) slot can be used to be notified about a value change.

Definition at line 24 of file WidgetUtils.cpp.

{
    auto* spinBox = new QSpinBox(parent);
    spinBox->setFocusPolicy(Qt::StrongFocus);
    spinBox->setToolTip(d.tooltip);
    spinBox->setMaximum(std::numeric_limits<int>::max());
    spinBox->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
 
    if (d.limits.hasLowerLimit())
        spinBox->setMinimum(static_cast<int>(d.limits.lowerLimit()));
    if (d.limits.hasUpperLimit())
        spinBox->setMaximum(static_cast<int>(d.limits.upperLimit()));
 
    spinBox->setValue(d.get());
 
    if (slot)
        QObject::connect(spinBox, qOverload<int>(&QSpinBox::valueChanged),
                         [=](int v) { slot(static_cast<uint>(v)); });
 
    return spinBox;
}

References UIntDescriptor::get, UIntDescriptor::limits, and UIntDescriptor::tooltip.

Referenced by AxisPropertyEditor::AxisPropertyEditor(), FormLayouter::addValue(), ResolutionFunctionEditor::createResolutionWidgets(), DistributionSelector::createSpinBox(), DetectorAlignmentEditor::createSpinBox(), and createSpinBox().

labelWithUnit() [1/2]

QString GUI::Util::labelWithUnit

(

const DoubleDescriptor &

d

)

Create a label with an optional unit in brackets, both taken from the given descriptor.

No trailing ':' will be appended

Definition at line 77 of file WidgetUtils.cpp.

{
    return labelWithUnit(d.label, d.unit);
}

References DoubleDescriptor::label, labelWithUnit(), and DoubleDescriptor::unit.

Here is the call graph for this function:

labelWithUnit() [2/2]

QString GUI::Util::labelWithUnit	(	const QString &	label,
		std::variant< QString, Unit >	unit
	)

Create a label with an optional unit in brackets.

No trailing ':' will be appended

Referenced by PolarizationAnalysisEditor::PolarizationAnalysisEditor(), ParameterTreeBuilder::addBackground(), ParameterTreeBuilder::addParameterItem(), DetectorAlignmentEditor::addVector(), PolarizationAnalysisEditor::addVector(), createScientificSpinBox(), createSpinBox(), and labelWithUnit().

restoreBackup()

template<typename T >

void GUI::Util::restoreBackup	(	T *	t,
		const QByteArray &	backup
	)

Definition at line 36 of file Backup.h.

{
    QXmlStreamReader r(backup);
    Streamer sr(&r);
    r.readNextStartElement();
    ASSERT(r.name() == "backup");
    t->serialize(sr);
}

Referenced by copyContents(), and CommandRemoveLayer::undo().