variant_registry_tree_model.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2014-10-06
 * Last modified : 2016-11-16
 *
 * Copyright (C) 2014-2016 Francois Mauger <mauger@lpccaen.in2p3.fr>
 *
 * 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 3 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; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 * Description:
 *
 *   Qt-based tree model for a variant registry.
 */

#ifndef DATATOOLS_CONFIGURATION_UI_VARIANT_REGISTRY_TREE_MODEL_H
#define DATATOOLS_CONFIGURATION_UI_VARIANT_REGISTRY_TREE_MODEL_H

// Third party:
// - Qt:
#include <QObject>
#include <QString>
#include <QList>
#include <QAbstractItemModel>
#include <QModelIndex>
#include <QVariant>
// - Boost:
#include <boost/scoped_ptr.hpp>

// This project
#include <datatools/logger.h>
#include <datatools/i_tree_dump.h>

namespace datatools {

  namespace configuration {

    // Forward declarations:
    class variant_record;
    class variant_registry;

    namespace ui {

      class tree_item : public QObject,
                        public datatools::i_tree_dumpable
      {
        Q_OBJECT

      public:

        enum column_index {
          CI_KEY   = 0,  
          CI_TYPE  = 1,  
          CI_VALUE = 2,  
          CI_DESCRIPTION = 3 
        };

        tree_item(variant_record & vr_, tree_item * parent_ = 0);

        virtual ~tree_item();

        void append_child(tree_item * child_);

        tree_item * grab_child(int row_);

        const tree_item * get_child(int row_) const;

        int get_child_count() const;

        int get_column_count() const;

        variant_record & grab_record();

        const variant_record & get_record() const;

        int get_row() const;

        bool has_parent() const;

        tree_item * grab_parent();

        const tree_item * get_parent() const;


        QVariant data(int column_) const;

        bool setData(int column_, const QVariant & value_);

        bool unsetData(int column_);

        void set_parent(tree_item * parent_);

        void set_logging(datatools::logger::priority p_);

        datatools::logger::priority get_logging() const;

        QList<tree_item *> & grab_children();

        const QList<tree_item *> & get_children() const;

        virtual void tree_dump(std::ostream & out = std::clog,
                               const std::string & title_ = "",
                               const std::string & indent_ = "",
                               bool inherit_ = false) const;

      private:

        datatools::logger::priority _logging_;  
        variant_record *            _record_;   
        tree_item *                 _parent_;   
        QList<tree_item *>          _children_; 

        friend class variant_registry_tree_model;

      };

      class variant_registry_tree_model : public QAbstractItemModel,
                                          public datatools::i_tree_dumpable
      {
        Q_OBJECT

      public:

        static const std::string & default_top_label();

        variant_registry_tree_model(QObject * parent_ = 0);

        virtual ~variant_registry_tree_model();

        bool has_root() const;

        void set_root(tree_item * node_);

        tree_item * grab_root();

        const tree_item * get_root() const;

        QModelIndex rootIndex() const;

        QModelIndex index(int row_,
                          int column_,
                          const QModelIndex &parent_) const;

        QModelIndex parent(const QModelIndex &child_) const;

        Qt::ItemFlags flags(const QModelIndex &index_) const;

        int rowCount(const QModelIndex &parent_) const;

        int columnCount(const QModelIndex &parent_) const;

        QVariant data(const QModelIndex &index_, int role_) const;

        bool setData(const QModelIndex & index_, const QVariant & value_, int role_ = Qt::EditRole);

        bool unsetData(const QModelIndex & index_, int role_ = Qt::EditRole);


        QVariant headerData(int section_,
                            Qt::Orientation orientation_,
                            int role_) const;

        void construct(variant_registry & registry_,
                       const std::string & registry_name_ = "");

        void set_registry_name(const std::string & registry_name_);

        // Return the name of the registry
        const std::string & get_registry_name() const;

        void set_logging(datatools::logger::priority p_);

        datatools::logger::priority get_logging() const;

        bool is_read_only() const;

        void set_read_only(bool);

        bool has_registry() const;

        variant_registry & grab_registry();

        const variant_registry & get_registry() const;

        bool has_restore_buffer() const;

        void reset_restore_buffer();

        virtual void tree_dump(std::ostream & out = std::clog,
                               const std::string & title_ = "",
                               const std::string & indent_ = "",
                               bool inherit_ = false) const;

        tree_item * node_from_index(const QModelIndex & index_) const;

      public slots:

        void slot_broadcast_data_change(const QModelIndex &, const QModelIndex &);

        void slot_store_to_restore_buffer(std::string * buffer_ = 0);

        void slot_load_from_restore_buffer(const std::string * buffer_ = 0);

        void slot_store_to_reg_file(const QString & out_reg_filename_) const;

        void slot_load_from_reg_file(const QString & in_reg_filename_);

      signals:

        void sig_read_only_changed(bool);

        void sig_registry_name_changed();

        void sig_logging_changed();

        void sig_registry_changed(std::string);

        void sig_registry_data_changed(std::string, std::string);

      private:

        tree_item * _construct_node_(variant_registry & registry_, variant_record & record_);

        tree_item * _node_from_index_(const QModelIndex & index_) const;

      private:

        logger::priority   _logging_;       
        bool               _read_only_;     
        std::string        _registry_name_; 
        variant_registry * _registry_;      
        tree_item *        _root_;          
        boost::scoped_ptr<std::string> _restore_buffer_; 

      };

    }  // end of namespace ui

  }  // end of namespace configuration

}  // end of namespace datatools

#endif // DATATOOLS_CONFIGURATION_UI_VARIANT_REGISTRY_TREE_MODEL_H

// Local Variables: --
// mode: c++ --
// c-file-style: "gnu" --
// tab-width: 2 --
// End: --