QML ListModel for interaction with C++

Quote:

---

You have QDeclarativeItem instances all over your code, just take a look.

---

This is the structure that works for me by now:

Code:

---

class QMLPtrAbstractItem : public QObject
{
	Q_OBJECT
public:
    virtual ~QMLPtrAbstractItem() { }
 
    virtual bool setData(int role, const QVariant &value) = 0;
    virtual QVariant getData(int role) const = 0;
 
    virtual int getUID() const = 0;
    virtual void setUID(int uid) = 0;
};
 
class EmpData : public QMLPtrAbstractItem
{
    Q_OBJECT
public:
    enum EmpRoles {
        Name = Qt::UserRole + 1,
        UID,
		Qualification
    };
 
    static QHash<int, QByteArray> getQMLRoles(){
        QHash<int, QByteArray> roles;
        roles[Name]				= "name";
        roles[UID]				= "uid";
        roles[Qualification]    = "qualification";
        return roles;
    }
 
    EmpData()  {}
 
    virtual QVariant getData(int role) const {
        if (role == Name)
            return getName();
        else if (role == UID)
            return getUID();
        else if (role == Qualification)
            return getQualification();
        return QVariant();
    }
 
    virtual bool setData(int role, const QVariant &value) {
        bool changed = false;
        if (role == Name){
            changed = true;
            setName(value.toString());
        }
        else if (role == UID){
            changed = true;
            setUID(value.toInt());
        }
        else if (role == Qualification){
            changed = true;
            setQualification(value.toString());
        }
        return changed;
    }
 
private:
.....
};
 
class TaskData : public QMLPtrAbstractItem
{
    Q_OBJECT
 
public:
    enum TaskRoles {
        UID = Qt::UserRole + 1,
        Name,
        BgColor1,
        BgColor2,
        XPos,
        YPos,
        Length,
        CreationUser,
        OrderType,
        Active,
        Index
    };
 
    static QHash<int, QByteArray> getQMLRoles(){
        QHash<int, QByteArray> roles;
        roles[UID]          = "uid";
        roles[Name]         = "name";
        roles[BgColor1]     = "bgColor1";
        roles[BgColor2]     = "bgColor2";
        roles[XPos]         = "xPos";
        roles[YPos]         = "yPos";
        roles[Length]       = "length";
        roles[CreationUser] = "creationuser";
        roles[OrderType]    = "orderType";
        roles[Active]       = "active";
        roles[Index]        = "index";
        return roles;
    }
 
    TaskData()  {
        _bgcolor1 = "#FEFEFE";
        _bgcolor2 = "#ededeb";
        _active = false;
    }
    virtual ~TaskData() { }
 
.....
 
    QVariant getData(int role) const {
        if (role == UID)
            return getUID();
        else if (role == Name)
            return getName();
        else if (role == BgColor1)
            return getBgColor1();
        else if (role == BgColor2)
            return getBgColor2();
        else if (role == XPos)
            return getXPos();
        else if (role == YPos)
            return getYPos();
        else if (role == Length)
            return getLength();
        else if (role == CreationUser)
            return getCreationUser();
        else if (role == OrderType)
            return getOrderType();
        else if (role == Active)
            return isActive();
        else if (role == Index)
            return getIndex();
        return QVariant();
    }
 
    bool setData(int role, const QVariant &value) {
        bool changed = false;
        if (role == UID){
            changed = true;
            setUID(value.toInt());
        }
        else if (role == Name){
            changed = true;
            setName(value.toString());
        }
        else if (role == BgColor1){
            changed = true;
            setBgColor1(value.toString());
        }
        else if (role == BgColor2){
            changed = true;
            setBgColor2(value.toString());
        }
        else if (role == XPos){
            changed = true;
            setXPos(value.toInt());
        }
        else if (role == YPos){
            changed = true;
            setYPos(value.toInt());
        }
        else if (role == Length){
            changed = true;
            setLength(value.toInt());
        }
        else if (role == CreationUser){
            changed = true;
            setCreationUser(value.toInt());
        }
        else if (role == OrderType){
            changed = true;
            setOrderType(value.toInt());
        }
        else if (role == Active){
            changed = true;
            setActive(value.toInt());
        }
        else if (role == Index){
            changed = true;
            setIndex(value.toInt());
        }
        return changed;
    }
 
private:
 ....
};
 
class OrderData : public TaskData
{
    Q_OBJECT
 ....
}
 
class EventData : public TaskData
{
    Q_OBJECT
...
}
 
class QMLPtrNotificationModel : public QAbstractListModel
{
    Q_OBJECT
....
}
 
QVariant QMLPtrNotificationModel::data(const QModelIndex &index, int role) const
{
    if (index.row() < 0 || index.row() > lst.size())
        return QVariant();
 
    const QMLPtrAbstractItem * const ptrItem = lst[index.row()];
 
    return ptrItem->getData(role);
}
 
bool QMLPtrNotificationModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if (index.row() >= 0 && index.row() < lst.size()) {
 
        QMLPtrAbstractItem * const ptrItem = lst.at(index.row());
        if(ptrItem){
            bool changed = ptrItem->setData(role, value);
 
            if(changed)
                emit dataChanged(index, index);
            return changed;
        }
        return false;
    }else
        qDebug() << "QMLPtrNotificationModel::setData( " << role << ")";
 
    return false;
}

---

QML looks like that:

Code:

---

Repeater {
        id: tasks
        model: taskModel // is registered via context() - holds OrderData and EventData via virtual binding
        delegate: TaskData { }
    }

---

There is no QDeclarativeItem anymore - and it compiles and works

Quote:

---

Different model instances of what?

---

Different Model instances: one for OrderData, one for EventData and one for EmpData

As i think the code will also work if i rename the classes to *Cpp? They just have the same names as the delegates - The QML delegate gets the
Data from the Model provided in the Repeater via accessing the roles of the model?!

TaskData.qml:

Code:

---

Text {
        id: taskName
        anchors.centerIn: parent
        text: name; // sets the name as text -> accesses the given model and executes data() for the role "name" which returns the name !?
         color: "white";
    }

---

Where is my structural error? =(

-------------------

I tried it by renamin the classes to *Cpp - works either

Code:

---

class EmpDataCpp : public QMLPtrAbstractItem { ... }
class TaskDataCpp : public QMLPtrAbstractItem { ... }
class OrderDataCpp : public TaskDataCpp { .. .}
class EventDataCpp : public TaskDataCpp { .. .}

---

With Delegates:

Code:

---

Repeater {
                id: empGrid
                model: empModel
                delegate: Employee { }
            }
    Repeater {
        id: tasks
        model: taskModel
        delegate: TaskData { }
    }

---

You are making it much more complicated than it needs to be. The item class needs not inherit QObject since you are not using any QObject related functionality in it. Next thing is that your model doesn't do anything fancy, it has functionality similar to QStandardItemModel, so you can use that instead of a custom model you need to care about. Third of all if you really insist on using a custom model class, there is no point in having various subclasses of QMLPtrAbstractItem because neither of these subclasses add anything to their base class functionality. Fourth of all if you get rid of QObject legacy, you can use objects instead of pointers to objects in your model which reduces possibilities of making an error somewhere in code.

Currently your code is equivalent to:

Code:

---

class MyModel : public QStandardItemModel {
public:
  MyModel(QObject *parent = 0) : QStandardItemModel(parent) { setColumnCount(1); }
  void setRoles(const QHash<int, QByteArray> & roleNames) { setRoleNames(roleNames); }
};
 
enum EmpRoles { Name = Qt::DisplayRole, UID = Qt::UserRole, Qualification };
enum TaskRoles { Name = Qt::DisplayRole, UID = Qt::UserRole, ... }
QHash<int, QByteArray> empNames;
empNames[EmpRoles::Name] = "name";
empNames[EmpRoles::UID] = "uid";
// etc.
MyModel empModel;
empModel.setRoles(empNames);
 
 
 
QHash<int, QByteArray> taskNames;
taskNames[TaskRoles::Name] = "name";
taskNames[TaskRoles::UID] = "uid";
MyModel taskModel;
taskModel.setRoles(taskNames);

---

My code seems much shorter and less error prone than yours.

Hmm .. that's correct - so you mean (and yes of course that seems much easier) using the standardmodel that way is much better -> and for inserting i use insertRow()/appendRow() and Insert QStandardItems to it (using the setData of the StandardItem for specifying the data for the specific role)

Was that your point for so far? ;) (btw - big thanks for your patience! - i hope i am not too exhausting ^^)

I had a couple of points. Mainly:

• no declarative items in the model,
• no custom classes that do not add anything new to the ecosystem,
• no need for custom models not doing anything different from what COTS are doing.