Roster model, account model, connection commena, connection report

ui/models/roster.cpp

@@ -0,0 +1,212 @@
+#include "roster.h"
+
+using namespace Models;
+
+Models::Roster::Roster(QObject* parent):
+    QAbstractItemModel(parent),
+    root(0)
+{
+    root = new Item(Item::root, {{"name", "root"}});
+}
+
+Models::Roster::~Roster()
+{
+    delete root;
+}
+
+void Models::Roster::addAccount(const QMap<QString, QVariant>& data)
+{
+    Item* acc = new Item(Item::account, data, root);
+    beginInsertRows(QModelIndex(), root->childCount(), root->childCount());
+    root->appendChild(acc);
+    accounts.insert(std::make_pair(acc->name(), acc));
+    endInsertRows();
+}
+
+QVariant Models::Roster::data (const QModelIndex& index, int role) const
+{
+    if (!index.isValid()) {
+        return QVariant();
+    }
+    
+    QVariant result;
+    
+    switch (role) {
+        case Qt::DisplayRole:
+        {
+            Item *item = static_cast<Item*>(index.internalPointer());
+            result = item->data(index.column());
+        }
+            break;
+        default:
+            break;
+    }
+    
+    return result;
+}
+
+int Models::Roster::columnCount (const QModelIndex& parent) const
+{
+    if (parent.isValid()) {
+        return static_cast<Item*>(parent.internalPointer())->columnCount();
+    } else {
+        return root->columnCount();
+    }
+}
+
+Qt::ItemFlags Models::Roster::flags(const QModelIndex& index) const
+{
+    if (!index.isValid()) {
+        return 0;
+    }
+    
+    return QAbstractItemModel::flags(index);
+}
+
+
+int Models::Roster::rowCount (const QModelIndex& parent) const
+{
+    Item *parentItem;
+    if (parent.column() > 0) {
+        return 0;
+    }
+    
+    if (!parent.isValid()) {
+        parentItem = root;
+    } else {
+        parentItem = static_cast<Item*>(parent.internalPointer());
+    }
+    
+    return parentItem->childCount();
+}
+
+QVariant Models::Roster::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    return QVariant();
+}
+
+QModelIndex Models::Roster::parent (const QModelIndex& child) const
+{
+    if (!child.isValid()) {
+        return QModelIndex();
+    }
+    
+    Item *childItem = static_cast<Item*>(child.internalPointer());
+    Item *parentItem = childItem->parentItem();
+    
+    if (parentItem == root) {
+        return QModelIndex();
+    }
+    
+    return createIndex(parentItem->row(), 0, parentItem);
+}
+
+QModelIndex Models::Roster::index (int row, int column, const QModelIndex& parent) const
+{
+    if (!hasIndex(row, column, parent)) {
+        return QModelIndex();
+    }
+    
+    Item *parentItem;
+    
+    if (!parent.isValid()) {
+        parentItem = root;
+    } else {
+        parentItem = static_cast<Item*>(parent.internalPointer());
+    }
+    
+    Item *childItem = parentItem->child(row);
+    if (childItem) {
+        return createIndex(row, column, childItem);
+    } else {
+        return QModelIndex();
+    }
+}
+
+
+Models::Roster::Item::Item(Type p_type, const QMap<QString, QVariant> &p_data, Item *p_parent):
+    type(p_type),
+    childItems(),
+    itemData(),
+    parent(p_parent)
+{
+    itemData.push_back(p_data.value("name"));
+}
+
+Models::Roster::Item::~Item()
+{
+    std::deque<Item*>::const_iterator itr = childItems.begin();
+    std::deque<Item*>::const_iterator end = childItems.end();
+    
+    for (;itr != end; ++itr) {
+        delete (*itr);
+    }
+}
+
+void Models::Roster::Item::appendChild(Models::Roster::Item* child)
+{
+    childItems.push_back(child);
+}
+
+Models::Roster::Item * Models::Roster::Item::child(int row)
+{
+    return childItems[row];
+}
+
+int Models::Roster::Item::childCount() const
+{
+    return childItems.size();
+}
+
+int Models::Roster::Item::row() const
+{
+    if (parent != 0) {
+        std::deque<Item*>::const_iterator itr = parent->childItems.begin();
+        std::deque<Item*>::const_iterator end = parent->childItems.end();
+        
+        for (int i = 0; itr != end; ++itr, ++i) {
+            if (*itr == this) {
+                return i;
+            }
+        }
+    }
+    
+    return 0;       //TODO not sure how it helps, i copy-pasted it from the example
+}
+
+Models::Roster::Item * Models::Roster::Item::parentItem()
+{
+    return parent;
+}
+
+int Models::Roster::Item::columnCount() const
+{
+    return itemData.size();
+}
+
+QString Models::Roster::Item::name() const
+{
+    return itemData[0].toString();
+}
+
+
+QVariant Models::Roster::Item::data(int column) const
+{
+    return itemData[column];
+}
+
+Models::Roster::ElId::ElId(const QString& p_account, const QString& p_name):
+    account(p_account),
+    name(p_name)
+{
+    
+}
+
+bool Models::Roster::ElId::operator <(const Models::Roster::ElId& other) const
+{
+    if (account == other.account) {
+        return name < other.name;
+    } else {
+        return account < other.account;
+    }
+}

ui/models/roster.h

@@ -0,0 +1,80 @@
+#ifndef MODELS_ROSTER_H
+#define MODELS_ROSTER_H
+
+#include <qabstractitemmodel.h>
+#include <deque>
+#include <map>
+
+namespace Models
+{
+
+class Roster : public QAbstractItemModel
+{
+    class Item;
+    class ElId;
+    Q_OBJECT
+public:
+    Roster(QObject* parent = 0);
+    ~Roster();
+
+    void addAccount(const QMap<QString, QVariant> &data);
+    
+    QVariant data ( const QModelIndex& index, int role ) const;
+    Qt::ItemFlags flags(const QModelIndex &index) const override;
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
+    int columnCount ( const QModelIndex& parent ) const;
+    int rowCount ( const QModelIndex& parent ) const;
+    QModelIndex parent ( const QModelIndex& child ) const;
+    QModelIndex index ( int row, int column, const QModelIndex& parent ) const;
+    
+private:
+    Item* root;
+    std::map<QString, Item*> accounts;
+    std::map<ElId, Item*> elements;
+    
+private:
+    class Item {
+    public:
+        enum Type {
+            account,
+            group,
+            contect,
+            conversation,
+            root
+        };
+        
+        explicit Item(Type p_type, const QMap<QString, QVariant> &data, Item *parentItem = 0);
+        ~Item();
+        
+        void appendChild(Item *child);
+        QString name() const;
+        
+        Item *child(int row);
+        int childCount() const;
+        int columnCount() const;
+        QVariant data(int column) const;
+        int row() const;
+        Item *parentItem();
+        
+        const Type type;
+        
+    private:
+        std::deque<Item*> childItems;
+        std::deque<QVariant> itemData;
+        Item* parent;
+    };
+    
+    class ElId {
+    public:
+        ElId (const QString& p_account, const QString& p_name);
+        
+        const QString account;
+        const QString name;
+        
+        bool operator < (const ElId& other) const;
+    };
+};
+
+}
+
+#endif // MODELS_ROSTER_H