LinkedModelGroups.h

Go to the documentation of this file.

/*
 * LinkedModelGroups.h - base classes for groups of linked models
 *
 * Copyright (c) 2019-2019 Johannes Lorenz <j.git$$$lorenz-ho.me, $$$=@>
 *
 * This file is part of LMMS - https://lmms.io
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef LMMS_LINKED_MODEL_GROUPS_H
#define LMMS_LINKED_MODEL_GROUPS_H
 
#include <cstddef>
 
#include "Model.h"
 
class QDomDocument;
class QDomElement;
 
namespace lmms
{

 

class LinkedModelGroup : public Model
{
        Q_OBJECT
public:
        /*
                Initialization
        */
        LinkedModelGroup(Model* parent) : Model(parent) {}
 
        /*
                Linking (initially only)
        */
        void linkControls(LinkedModelGroup *other);
 
        /*
                Models
        */
        struct ModelInfo
        {
                QString m_name;
                class AutomatableModel* m_model;
                ModelInfo() { /* hopefully no one will use this */ } // TODO: remove?
                ModelInfo(const QString& name, AutomatableModel* model)
                        : m_name(name), m_model(model) {}
        };
 
        // TODO: refactor those 2
        template<class Functor>
        void foreach_model(const Functor& ftor)
        {
                for (auto itr = m_models.begin(); itr != m_models.end(); ++itr)
                {
                        ftor(itr->first, itr->second);
                }
        }
 
        template<class Functor>
        void foreach_model(const Functor& ftor) const
        {
                for (auto itr = m_models.cbegin(); itr != m_models.cend(); ++itr)
                {
                        ftor(itr->first, itr->second);
                }
        }
 
        std::size_t modelNum() const { return m_models.size(); }
        bool containsModel(const QString& name) const;
        void removeControl(AutomatableModel *);
 
        /*
                Load/Save
        */
        void saveValues(class QDomDocument& doc, class QDomElement& that);
        void loadValues(const class QDomElement& that);
 
signals:
        // NOTE: when separating core from UI, this will need to be removed
        // (who would know if the client is Qt, i.e. it may not have slots at all)
        // In this case you'd e.g. send the UI something like
        // "/added <model meta info>"
        void modelAdded(lmms::AutomatableModel* added);
        void modelRemoved(lmms::AutomatableModel* removed);
 
public:
        AutomatableModel* getModel(const std::string& s)
        {
                auto itr = m_models.find(s);
                return (itr == m_models.end()) ? nullptr : itr->second.m_model;
        }

        void addModel(class AutomatableModel* model, const QString& name);
        bool eraseModel(const QString& name);

        void clearModels();
 
private:
        std::map<std::string, ModelInfo> m_models;
};
 

class LinkedModelGroups
{
public:
        virtual ~LinkedModelGroups() = default;
 
        void linkAllModels();
 
        /*
                Load/Save
        */
        void saveSettings(class QDomDocument& doc, class QDomElement& that);
        void loadSettings(const class QDomElement& that);
 
        /*
                General
        */
        virtual LinkedModelGroup* getGroup(std::size_t idx) = 0;
        virtual const LinkedModelGroup* getGroup(std::size_t idx) const = 0;
};
 
 
} // namespace lmms
 
#endif // LMMS_LINKED_MODEL_GROUPS_H