SelectionProperty.h

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Descriptor/SelectionProperty.h
//! @brief     Defines class SelectionProperty
//!
//! @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_SELECTIONPROPERTY_H
#define BORNAGAIN_GUI_MODEL_DESCRIPTOR_SELECTIONPROPERTY_H
 
#include "GUI/Model/Descriptor/SelectionDescriptor.h"
#include "GUI/Support/XML/Streamer.h"
 
//! Class for representing a selection, its attributes and its accessors.
//!
//! A "selection" in this context is a class instance out of a range of possible class instances.
//!
//! Example:
//! A distribution can be represented by DistributionGateItem, DistributionLorentzItem and more. The
//! common base class is DistributionItem. To store the currently distribution, you may use a member
//! of DistributionItem* which than holds an instance of the currently selected distribution (e.g.
//! DistributionGateItem*). To select between distributions, you need a combo box filled with the
//! distribution names, a label for the combo box, and so on.
//!
//! This class provides many of these attributes and functionalities:
//! * A pointer to the common base class (given as the template argument T). The lifetime of this
//! pointer is handled in here.
//! * label: a label of e.g. a spin box
//! * tooltip: tooltip for e.g. a spin box
//! * persistent tag: a name to serialize this property. Do not change this string, since it is
//!   serialized!
//! * A list of available options (e.g. the names of the distributions)
//! * A descriptor which provides some of the given information, as well as getters/setters.
//!
//! For the initialization of a SelectionProperty there are helper methods. They are not necessarily
//! to be called if they are not convenient. They are only there to help initialization e.g by using
//! a catalog. If no catalog exists for the given case, the initialization can be done by any means.
//!
//! This means especially that this class is **not** relying on the existence of a related catalog
//! class - a catalog helps but is not mandatory.
//!
//! \sa SelectionDescriptor
//!
template <typename T>
class SelectionProperty {
public:
    ~SelectionProperty() { delete m_p; }
 
    //! Initialize by means of a catalog class and optional creation arguments.
    //!
    //! The current selection will be initialized with the first type in the catalog types. The
    //! optional arguments are the arguments which may be necessary for the creation method in the
    //! catalog.
    template <typename Catalog, typename... ArgsForCreation>
    void init(const QString& label, const QString& tooltip, const QString& persistentTag,
              ArgsForCreation... argsForCreation)
    {
        m_persistentTag = persistentTag;
        initDescriptor<Catalog>(label, tooltip, Catalog::types(), argsForCreation...);
        m_descriptor.setCurrentIndex(0);
    }
 
    //! Initialize by means of a catalog class and an initializer function.
    //!
    //! The current selection will be initialized with the first type in the catalog types.
    //! Each newly created item can be initialized with the given initializer method. Note that the
    //! item creation will take place also after a call to this method, so take care that the given
    //! initializer stays valid throughout the lifetime of this SelectionProperty instance.
    //!
    //! The initializer function takes two arguments: The first is the new item, the second is the
    //! old one (if present; can be null). This is intended to maybe copy values from the old to the
    //! new selection. The old item also can be ignored, always according to the current
    //! needs.
    template <typename Catalog>
    void initWithInitializer(const QString& label, const QString& tooltip,
                             const QString& persistentTag,
                             std::function<void(T newItem, const T oldItem)> initializer)
    {
        m_initializer = initializer;
        m_persistentTag = persistentTag;
 
        initDescriptor<Catalog>(label, tooltip, Catalog::types());
        m_descriptor.setCurrentIndex(0);
    }
 
    //! Initialize by means of a catalog class, a subsection of allowed types and an initializer
    //! function.
    //!
    //! Same as before, but only a subset of types available in a catalog shall be used.
    //! The current selection will be initialized with the first type in the given types subset.
    //! Each newly created item can be initialized with the given initializer method. Note that the
    //! item creation will take place also after a call to this method, so take care that the given
    //! initializer stays valid throughout the lifetime of this SelectionProperty instance.
    //!
    //! The initializer function takes two arguments: The first is the new item, the second is the
    //! old one (if present; can be null). This is intended to maybe copy values from the old to the
    //! new selection. The old item also can be ignored, always according to the current
    //! needs.
    template <typename Catalog>
    void initWithInitializer(const QString& label, const QString& tooltip,
                             const QString& persistentTag,
                             const QVector<typename Catalog::Type>& types,
                             std::function<void(T newItem, const T oldItem)> initializer)
    {
        m_initializer = initializer;
        m_persistentTag = persistentTag;
 
        initDescriptor<Catalog>(label, tooltip, types);
        m_descriptor.setCurrentIndex(0);
    }
 
    //! Returns a descriptor working on this property.
    SelectionDescriptor<T> descriptor() const { return m_descriptor; }
 
    //! Cast to a descriptor working on this property.
    operator SelectionDescriptor<T>() const { return m_descriptor; }
 
    //! Direct access to the stored pointer
    T operator->() const { return m_p; }
 
    //! Direct access to the stored pointer
    T get() const { return m_p; }
 
    //! Directly set the new item.
    void set(T t, bool callInitializer = false)
    {
        if (callInitializer && m_initializer)
            m_initializer(t, m_p);
        delete m_p;
        m_p = t;
    }
 
    //! Directly set the new item.
    template <typename S, typename... ArgsForConstructor>
    S* set(ArgsForConstructor... argsForConstructor)
    {
        S* s = new S(argsForConstructor...);
        if (s != nullptr && m_initializer)
            m_initializer(s, m_p);
        m_p = s;
        return s;
    }
 
    //! Persistent tag for serializing.
    QString persistentTag() const { return m_persistentTag; }
 
 
private:
    template <typename Catalog, typename... ArgsForCreation>
    void initDescriptor(const QString& label, const QString& tooltip,
                        const QVector<typename Catalog::Type>& types,
                        ArgsForCreation... argsForCreation)
 
    {
        auto setCurrentIndex = [=](int current) {
            auto* p = Catalog::create(types[current], argsForCreation...);
            if (m_initializer)
                m_initializer(p, m_p);
            m_p = p;
        };
 
        m_descriptor.label = label;
        m_descriptor.tooltip = tooltip;
        for (const auto type : types)
            m_descriptor.options << Catalog::uiInfo(type).menuEntry;
        m_descriptor.currentIndexSetter = setCurrentIndex;
        m_descriptor.currentIndexGetter = [=]() { return types.indexOf(Catalog::type(m_p)); };
        m_descriptor.currentItem = [=] { return m_p; };
    }
 
private:
    QString m_persistentTag;             //!< Persistent tag for serializing
    SelectionDescriptor<T> m_descriptor; //!< descriptor, holding attributes like label, tooltip
    T m_p = nullptr;                     //!< Current selection
 
    //! initializer function. Can be empty.
    //! The first argument is the new item, the second is the old one if present; can be null.
    //! This is intended to maybe copy values from the old to the new selection. oldItem also can be
    //! ignored if not relevant,
    std::function<void(T newItem, const T oldItem)> m_initializer;
};
 
// Extends namespace defined in GUI/Model/XML/Serialize.h
namespace Serialize {
 
//! Serializes an item from a catalog.
//! Passes optional arguments to the constructor.
template <typename Catalog, typename... ArgsForCreation>
void rwSelected(Streamer& s, SelectionProperty<typename Catalog::CatalogedType*>& d,
                ArgsForCreation... argsForCreation);
 
} // namespace Serialize
 
//  ************************************************************************************************
//  Template implementation
//  ************************************************************************************************
 
template <typename Catalog, typename... ArgsForCreation>
void Serialize::rwSelected(Streamer& s, SelectionProperty<typename Catalog::CatalogedType*>& d,
                           ArgsForCreation... argsForCreation)
{
    if (QXmlStreamWriter* w = s.xmlWriter()) {
        typename Catalog::CatalogedType* p = d.get();
        s.write<Catalog>(d.persistentTag(), p);
    } else if (QXmlStreamReader* r = s.xmlReader()) {
        typename Catalog::CatalogedType* p = nullptr;
        s.read<Catalog>(d.persistentTag(), p, argsForCreation...);
        d.set(p);
    }
}
 
#endif // BORNAGAIN_GUI_MODEL_DESCRIPTOR_SELECTIONPROPERTY_H