SelectionDescriptor.h

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Descriptor/SelectionDescriptor.h
//! @brief     Defines class SelectionDescriptor
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2021
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#ifndef BORNAGAIN_GUI_MODEL_DESCRIPTOR_SELECTIONDESCRIPTOR_H
#define BORNAGAIN_GUI_MODEL_DESCRIPTOR_SELECTIONDESCRIPTOR_H
 
#include "GUI/Model/BaseItem/GroupItem.h"
#include "GUI/Util/ComboProperty.h"
#include <QString>
#include <QStringList>
#include <functional>
 
using std::function;
 
//! Abstract base class for SelectionDescriptor to ease referencing.
class AbstractSelectionDescriptor {
public:
    virtual ~AbstractSelectionDescriptor() = default;
 
    //! Set currently selected option
    virtual void setCurrentIndex(int newIndex) const = 0;
 
    //! Get currently selected option
    virtual int currentIndex() const = 0;
};
 
//! Describes a selection (various possibilities and the current one).
//!
//! Usually a selection is presented as a combo box.
//! Right now with SessionModel still in place, in many cases a selection changes the current item
//! of a group item, i.e. it changes the class of a certain child item (e.g.
//! XRotationItem*/YRotationItem*/...).
//! Also a SessionItem holding only a ComboProperty (but not switching children like GroupItem) can
//! be wrapped. For example IntensityDataItem::gradient() is simply a list of QStrings.
//!
//! With the migration, more and more SelectionDescriptor operate on a SelectionProperty. Please
//! refer to this class for more information.
//!
//! The template parameter defines the type of the current item. This can be a pointer to a common
//! base class (like RotationItem*), but it also can be a std::variant<...>, which is useful if
//! no dedicated common base class exists (like for the roughness items LayerZeroRoughnessItem and
//! LayerBasicRoughnessItem).
//! If not used with a GroupItem, but with a "normal" ComboProperty holder, the template parameter
//! can be a QString, so currentItem() returns the currently selected string.
//!
//! Note that this class does not provide (*implement*) a selection, but *provide
//! information* about a selection. For implementing a selection, please see SelectionProperty.
//!
//! By using this class, the underlying data scheme is hidden from the user of the data. This e.g.
//! eases SessionItem migration. The underlying implementation can be a GroupItem, a simple pointer
//! member, a std::variant or any other construction to define a selection.
//!
//! For easy UI creation, there are functions like GUI:Util::createSelectionCombo() which take a
//! descriptor and fully initialize the created combo box.
//!
//! \sa SelectionProperty
//!
template <typename T>
class SelectionDescriptor : public AbstractSelectionDescriptor {
public:
    SelectionDescriptor() = default;
 
    //! Initialize the members by means of a SessionItem containing a ComboProperty. This can be
    //! a GroupItem or any other property.
    //!
    //! currentItem can only be initialized if the template parameter is a pointer (like
    //! RotationItem*). If it is e.g. a std::variant<>, the currentItem has to be initialized by the
    //! caller. Only for easier migration. Should be removed after SessionItem refactoring.
    explicit SelectionDescriptor(SessionItem* item)
    {
        label = item->displayName();
        tooltip = item->toolTip();
        options = item->value().value<ComboProperty>().getValues();
        currentIndexSetter = [=](int index) {
            auto comboProperty = item->value().value<ComboProperty>();
 
            if (comboProperty.currentIndex() != index) {
                comboProperty.setCurrentIndex(index);
                item->setValue(QVariant::fromValue<ComboProperty>(comboProperty));
            }
        };
        currentIndexGetter = [=] { return item->value().value<ComboProperty>().currentIndex(); };
 
        if constexpr (std::is_pointer<T>::value) {
            if (auto* groupItem = dynamic_cast<GroupItem*>(item))
                currentItem = [=] { return dynamic_cast<T>(groupItem->currentItem()); };
        } else if constexpr (std::is_same<T, QString>::value)
            currentItem = [=] { return item->value().value<ComboProperty>().getValue(); };
    }
 
    operator T() const { return currentItem(); }
 
    void setCurrentIndex(int newIndex) const override { currentIndexSetter(newIndex); }
 
    int currentIndex() const override { return currentIndexGetter(); }
 
    QString label;                          //!< A label text (short, no trailing colon)
    QString tooltip;                        //!< Tooltip text
    QStringList options;                    //!< List of options, usually presented as combo entries
    function<void(int)> currentIndexSetter; //!< Function to set currently selected option
    function<int()> currentIndexGetter;     //!< Function to get currently selected option
    function<T()> currentItem;              //!< Function to get currently selected item
};
 
#endif // BORNAGAIN_GUI_MODEL_DESCRIPTOR_SELECTIONDESCRIPTOR_H