Initial commit of Gel.

This implements the bare bones of what I want this to do.

Author: jrbarron

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Cutehacks AS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,108 @@
+Gel is a framework for storing JSON objects in a ListView compatible model.
+It offers more functionality than the builtin ListModel by offering support
+for sorting and filtering.
+
+# Installation
+
+Gel is available on qpm:
+
+`qpm install com.cutehacks.gel`
+
+# Usage
+
+In your main.cpp:
+
+```
+#include "com/cutehacks/gel/gel.h"
+	
+int main(int argc, char *argv[])
+{
+	...
+	
+	com::cutehacks::gel::registerEngine(&engine);
+	
+	...
+}
+```
+
+The above function will register two QML types with the QML engine which are documented
+below.
+
+# API
+
+## JsonListModel
+
+A implementation of a model specifically designed for storing for JSON objects. The item
+has the following properties and functions:
+
+### idAttribute : property string: "id"
+
+Specifies the name of the property that should be used to uniquely identify 
+this object within the model. Adding an object with the same value for this
+property will update the existing object instead of creating a new one.
+
+### add(jsobject | jsarray | string | number | date) : function
+
+Add a new JSON object or an array of objects to the model
+
+### remove(jsobject | string | number | date) : function
+
+Remove the specified object from the model.
+
+### clear() : function
+
+Remove all items from the model.
+
+## Collection
+
+An item for sorting an filtering a JsonListModel. The Collection itself does not
+store any data, but rather proxies the data stored inside the source model.
+
+### model : JsonListModel
+
+The model used to store the JSON objects for this collection.
+
+### comparator : string | function
+
+Specifies the comparator to use when sorting the collection.
+
+* If a string is passed to this property, it refers to the property name that
+ should be used for sorting.
+* If a function is passed to this property, it should have the following signature:
+
+```
+function lessThan(a, b) {
+	return a.value < b.value;
+}
+```
+
+The function will receive two arguments that are JSON objects. The implementation of 
+this function is responsible for comparing the two items and returning true if `a` is
+less than `b`; otherwise false.
+
+### filter : function
+
+A function indicating which items should be included in th resulting collection. The
+function should return true for items that should be included; otherwise false.
+
+## Example
+
+The following is an example of using the items:
+
+```
+    Collection {
+        id: collection
+        model: JsonListModel {
+            id: jsonModel
+        }
+        filter: function(item) {
+            return item.value.indexOf("foo") >= 0;
+        }
+        comparator: "value"
+    }
+
+```
+
+The above snippet will sort a list of JSON objects based on the "value"
+property, but will only show objects whose "value" property contains the
+word "foo".

collection.cpp

@@ -0,0 +1,108 @@
+#include "collection.h"
+#include "jsonlistmodel.h"
+
+Collection::Collection(QObject *parent) : QSortFilterProxyModel(parent)
+{
+    sort(0);
+}
+
+QJSValue Collection::comparator() const
+{
+    return m_comparator;
+}
+
+QJSValue Collection::filter() const
+{
+    return m_filter;
+}
+
+JsonListModel *Collection::model() const
+{
+    return qobject_cast<JsonListModel*>(sourceModel());
+}
+
+void Collection::setComparator(QJSValue comparator)
+{
+    if (m_comparator.strictlyEquals(comparator))
+        return;
+
+    m_comparator = comparator;
+    updateModel();
+    emit comparatorChanged(comparator);
+}
+
+void Collection::setFilter(QJSValue filter)
+{
+    if (m_filter.strictlyEquals(filter))
+        return;
+
+    m_filter = filter;
+    invalidateFilter();
+    emit filterChanged(filter);
+}
+
+void Collection::setModel(JsonListModel *model)
+{
+    JsonListModel *oldModel = qobject_cast<JsonListModel*>(sourceModel());
+    if (oldModel == model)
+        return;
+
+    if (oldModel) {
+        disconnect(oldModel, SIGNAL(roleAdded(QString)),
+                   this, SLOT(resetInternalData()));
+    }
+
+    setSourceModel(model);
+    updateModel();
+    connect(model, SIGNAL(roleAdded(QString)), this, SLOT(roleAdded(QString)));
+
+    emit modelChanged(model);
+}
+
+void Collection::roleAdded(QString)
+{
+    resetInternalData();
+    updateModel();
+}
+
+void Collection::updateModel()
+{
+    if (model() && m_comparator.isString()) {
+        int role = model()->getRole(m_comparator.toString());
+        setSortRole(role);
+    }
+//    sort(0);
+}
+
+
+bool Collection::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
+{
+    if (m_filter.isCallable()) {
+        QJSValue result = m_filter.call(QJSValueList() << model()->at(source_row));
+        return result.toBool();
+    } else {
+        return QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);
+    }
+}
+
+bool Collection::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
+{
+    /*if (m_comparator.isString()) {
+        QString compare = m_comparator.toString();
+        QJSValue left = model()->at(source_left.row());
+        QJSValue right = model()->at(source_right.row());
+
+        // TODO: Avoid variant?
+        QVariant leftVal = left.property(compare).toVariant();
+        QVariant rightVal = right.property(compare).toVariant();
+        return leftVal < rightVal;
+    } else */
+    if (m_comparator.isCallable()) {
+        QJSValue left = model()->at(source_left.row());
+        QJSValue right = model()->at(source_right.row());
+        QJSValue result = m_comparator.call(QJSValueList() << left << right);
+        return result.toBool();
+    } else {
+        return QSortFilterProxyModel::lessThan(source_left, source_right);
+    }
+}

collection.h

@@ -0,0 +1,47 @@
+#ifndef COLLECTION_H
+#define COLLECTION_H
+
+#include <QtCore/QSortFilterProxyModel>
+#include <QtQml/QJSValue>
+
+class JsonListModel;
+
+class Collection : public QSortFilterProxyModel
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QJSValue comparator READ comparator WRITE setComparator NOTIFY comparatorChanged)
+    Q_PROPERTY(QJSValue filter READ filter WRITE setFilter NOTIFY filterChanged)
+    Q_PROPERTY(JsonListModel* model READ model WRITE setModel NOTIFY modelChanged)
+
+public:
+    Collection(QObject *parent = 0);
+
+    QJSValue comparator() const;
+    QJSValue filter() const;
+    JsonListModel *model() const;
+
+public slots:
+    void setComparator(QJSValue comparator);
+    void setFilter(QJSValue filter);
+    void setModel(JsonListModel* model);
+
+private slots:
+    void roleAdded(QString);
+
+signals:
+    void comparatorChanged(QJSValue comparator);
+    void filterChanged(QJSValue filter);
+    void modelChanged(JsonListModel* model);
+
+protected:
+    void updateModel();
+    bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const;
+    bool lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const;
+
+private:
+    mutable QJSValue m_comparator;
+    mutable QJSValue m_filter;
+};
+
+#endif // COLLECTION_H

com_cutehacks_gel.pri

@@ -0,0 +1,9 @@
+
+HEADERS += \
+    $$PWD/jsonlistmodel.h \
+    $$PWD/collection.h \
+    $$PWD/gel.h
+
+SOURCES += \
+    $$PWD/jsonlistmodel.cpp \
+    $$PWD/collection.cpp

gel.h

@@ -0,0 +1,66 @@
+#ifndef GEL_H
+#define GEL_H
+
+#ifdef QPM_USE_NS
+
+#undef _GET_OVERRIDE
+#undef _QPM_BEGIN_NAMESPACE_1
+#undef _QPM_BEGIN_NAMESPACE_2
+#undef _QPM_BEGIN_NAMESPACE_2
+#undef _QPM_BEGIN_NAMESPACE_4
+#undef QPM_BEGIN_NAMESPACE
+#undef _QPM_END_NAMESPACE_1
+#undef _QPM_END_NAMESPACE_2
+#undef _QPM_END_NAMESPACE_2
+#undef _QPM_END_NAMESPACE_4
+#undef QPM_END_NAMESPACE
+
+#define _GET_OVERRIDE(_1, _2, _3, _4, NAME, ...) NAME
+
+#define _QPM_BEGIN_NAMESPACE_1(a) \
+    namespace a {
+#define _QPM_BEGIN_NAMESPACE_2(a, b) \
+    _QPM_BEGIN_NAMESPACE_1(a) namespace b {
+#define _QPM_BEGIN_NAMESPACE_3(a, b, c) \
+    _QPM_BEGIN_NAMESPACE_2(a, b) namespace c {
+#define _QPM_BEGIN_NAMESPACE_4(a, b, c, d) \
+    _QPM_BEGIN_NAMESPACE_3(a, b, c) namespace d {
+
+#define QPM_BEGIN_NAMESPACE(...) _GET_OVERRIDE(__VA_ARGS__, \
+    _QPM_BEGIN_NAMESPACE_4, \
+    _QPM_BEGIN_NAMESPACE_3, \
+    _QPM_BEGIN_NAMESPACE_2, \
+    _QPM_BEGIN_NAMESPACE_1)(__VA_ARGS__)
+
+#define _QPM_END_NAMESPACE_1 };
+#define _QPM_END_NAMESPACE_2 } };
+#define _QPM_END_NAMESPACE_3 } } };
+#define _QPM_END_NAMESPACE_4 } } } };
+
+#define QPM_END_NAMESPACE(...) _GET_OVERRIDE(__VA_ARGS__, \
+    _QPM_END_NAMESPACE_4, \
+    _QPM_END_NAMESPACE_3, \
+    _QPM_END_NAMESPACE_2, \
+    _QPM_END_NAMESPACE_1)
+
+#else
+#define QPM_BEGIN_NAMESPACE(...)
+#define QPM_END_NAMESPACE(...)
+#endif // QPM_USE_NS
+
+#include <QtQml>
+#include "jsonlistmodel.h"
+#include "collection.h"
+
+QPM_BEGIN_NAMESPACE(com, cutehacks, gel)
+
+void registerEngine(QQmlEngine *engine)
+{
+    qmlRegisterType<JsonListModel>("com.cutehacks.gel", 1, 0, "JsonListModel");
+    qmlRegisterType<Collection>("com.cutehacks.gel", 1, 0, "Collection");
+}
+
+QPM_END_NAMESPACE(com, cutehacks, gel)
+
+#endif // GEL_H
+