PropertyNameListModel.hh 7.4 KB
Newer Older
Jan Möbius's avatar
 
Jan Möbius committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
/*
 * PropertyNameListModel.hh
 *
 *  Created on: Feb 29, 2012
 *      Author: ebke
 */

#ifndef PROPERTYNAMELISTMODEL_HH_
#define PROPERTYNAMELISTMODEL_HH_

#include <OpenMesh/Core/Utils/BaseProperty.hh>

#include <QAbstractListModel>

#include <set>
#include <vector>
#include <algorithm>

class PropertyNameListModel: public QAbstractListModel {
    public:
        enum ENTITY_FILTER {
            EF_ANY      = 0x0F,
            EF_FACE     = 0x01,
            EF_EDGE     = 0x02,
            EF_HALFEDGE = 0x04,
            EF_VERTEX   = 0x08,
        };

        static const char *entity2str(ENTITY_FILTER entity);

        class TypeInfoWrapper {
            public:
                TypeInfoWrapper(const std::type_info & ti, const char *friendlyName) : ti(&ti), friendlyName(friendlyName) {}
                TypeInfoWrapper(const std::type_info & ti) : ti(&ti) {}

                operator const std::type_info *() const { return ti; }
                operator const std::type_info &() const { return *ti; }
                operator const char *() const { return friendlyName; }

                const std::type_info *operator->() const { return ti; }
                const std::type_info &get() const { return *ti; }
                const char *getName() const { return friendlyName; }

                bool operator==(const TypeInfoWrapper & other) const {
                    /*
                     * We compare name strings, not the type ids themselves because
                     * the same type from different SOs will give different type ids.
                     */
                    return strcmp(ti->name(), other.ti->name()) == 0;
                }

                bool operator<(const TypeInfoWrapper & other) const {
                    return strcmp(ti->name(), other.ti->name()) < 0;
                }

            private:
                const std::type_info *ti;
                const char *friendlyName;
        };

        class PROP_INFO {
            public:
                PROP_INFO(const std::string &propName, const TypeInfoWrapper &typeinfo, ENTITY_FILTER entity) :
                    propName_(propName), typeinfo_(typeinfo), entity(entity) {}

                QString toString() const {
                    return tr("%3 %1 : %2").arg(propName_.c_str()).arg(friendlyTypeName()).arg(QString::fromUtf8(entity2str(entity)));
                }

                bool operator==(const PROP_INFO &rhs) const {
                    return propName_ == rhs.propName_ && typeinfo_ == rhs.typeinfo_ && entity == rhs.entity;
                }

                bool operator<(const PROP_INFO &rhs) const {
                    if (entity != rhs.entity) return entity < rhs.entity;

                    int result = propName_.compare(rhs.propName_);
                    if (result) return result < 0;

                    return typeinfo_ < rhs.typeinfo_;
                }

                inline bool isFaceProp() const { return entity == EF_FACE; }
                inline bool isEdgeProp() const { return entity == EF_EDGE; }
                inline bool isHalfedgeProp() const { return entity == EF_HALFEDGE; }
                inline bool isVertexProp() const { return entity == EF_VERTEX; }

                inline const std::string &propName() const { return propName_; }
                inline const char *friendlyTypeName() const { return typeinfo_.getName(); }
                inline const TypeInfoWrapper &typeinfo() const { return typeinfo_; }
                inline ENTITY_FILTER entityType() const { return entity; }

            private:
                std::string propName_;
                TypeInfoWrapper typeinfo_;
                ENTITY_FILTER entity;
        };

    public:
        PropertyNameListModel(QObject *parent = 0);
        virtual ~PropertyNameListModel();

        virtual int rowCount(const QModelIndex & parent = QModelIndex()) const;
        virtual QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const;
        virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;

        /**
         * @param typeIdFilter If NULL, do not filter by type.
         */
        template<typename MeshT>
        void refresh(MeshT *mesh, ENTITY_FILTER entityFilterMask, std::type_info *typeIdFilter) {
            std::vector<PROP_INFO> propList;

            if (mesh) {
                if (entityFilterMask & EF_FACE)
                    gatherProperties(mesh, mesh->fprops_begin(), mesh->fprops_end(), typeIdFilter, std::back_inserter(propList), EF_FACE);

                if (entityFilterMask & EF_EDGE)
                    gatherProperties(mesh, mesh->eprops_begin(), mesh->eprops_end(), typeIdFilter, std::back_inserter(propList), EF_EDGE);

                if (entityFilterMask & EF_HALFEDGE)
                    gatherProperties(mesh, mesh->hprops_begin(), mesh->hprops_end(), typeIdFilter, std::back_inserter(propList), EF_HALFEDGE);

                if (entityFilterMask & EF_VERTEX)
                    gatherProperties(mesh, mesh->vprops_begin(), mesh->vprops_end(), typeIdFilter, std::back_inserter(propList), EF_VERTEX);
            }

            std::sort(propList.begin(), propList.end());

            if (propList != propList_) {
                if (!tryInsertionsDeletions(propList)) {
                    beginResetModel();
                    propList_.swap(propList);
                    endResetModel();
                }
            }
        }

        /** Implements an unsophisticated heuristic to translate the difference
         * between propList and propList_ into a series of insertions and deletions.
         *
         * @return True if such a sequence was found, false otherwise.
         */
        bool tryInsertionsDeletions(std::vector<PROP_INFO> &propList);

        template<typename MeshT, typename OUTPUT_ITERATOR>
        void gatherProperties(MeshT *mesh,
                              typename MeshT::prop_iterator props_first,
                              typename MeshT::prop_iterator props_last,
                              std::type_info *typeIdFilter, OUTPUT_ITERATOR oit,
                              ENTITY_FILTER entity) {

            for (typename MeshT::prop_iterator pit = props_first; pit != props_last; ++pit) {
                OpenMesh::BaseProperty * const baseProp = *pit;
                if (!baseProp) continue;

                TypeInfoWrapper bp_type = typeid(*baseProp);
                TYPE_INFO_SET::const_iterator sane_prop_it = sane_prop_types.find(bp_type);
                if ((typeIdFilter == 0 || TypeInfoWrapper(*typeIdFilter) == bp_type) && sane_prop_it != sane_prop_types.end()) {
                    *oit++ = PROP_INFO(baseProp->name(), *sane_prop_it, entity);
                }
            }
        }

        const PROP_INFO &operator[] (size_t index) {
            return propList_[index];
        }

    protected:
        std::vector<PROP_INFO> propList_;

    public:
        static const TypeInfoWrapper proptype_bool;
        static const TypeInfoWrapper proptype_int;
        static const TypeInfoWrapper proptype_uint;
        static const TypeInfoWrapper proptype_double;
        static const TypeInfoWrapper proptype_Vec3d;
        static const TypeInfoWrapper proptype_Vec3f;
        static const TypeInfoWrapper proptype_SkinWeights;

    private:
        typedef std::set<TypeInfoWrapper> TYPE_INFO_SET;
        static const TypeInfoWrapper prop_types[];
        static const TYPE_INFO_SET sane_prop_types;
};

#endif /* PROPERTYNAMELISTMODEL_HH_ */