mirror of
https://github.com/swift-project/pilotclient.git
synced 2026-04-01 13:36:48 +08:00
267 lines
10 KiB
C++
267 lines
10 KiB
C++
/* Copyright (C) 2013
|
|
* swift project Community / Contributors
|
|
*
|
|
* This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
|
|
* directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
|
|
* including this file, may be copied, modified, propagated, or distributed except according to the terms
|
|
* contained in the LICENSE file.
|
|
*/
|
|
|
|
//! \file
|
|
|
|
#ifndef BLACKGUI_LISTMODELBASE_H
|
|
#define BLACKGUI_LISTMODELBASE_H
|
|
|
|
#include "blackgui/models/columns.h"
|
|
#include "blackgui/updateworker.h"
|
|
#include "blackmisc/propertyindex.h"
|
|
#include <QAbstractItemModel>
|
|
#include <QThread>
|
|
|
|
namespace BlackGui
|
|
{
|
|
namespace Models
|
|
{
|
|
//! Non templated base class, allows Q_OBJECT and signals to be used
|
|
class CListModelBaseNonTemplate : public QAbstractListModel
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
//! Number of elements when to use asynchronous updates
|
|
static const int asyncThreshold = 50;
|
|
|
|
//! Destructor
|
|
virtual ~CListModelBaseNonTemplate() {}
|
|
|
|
//! \copydoc QAbstractListModel::columnCount()
|
|
virtual int columnCount(const QModelIndex &modelIndex) const override;
|
|
|
|
//! \copydoc QAbstractItemModel::headerData()
|
|
virtual QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
|
|
|
|
//! Column to property index
|
|
virtual BlackMisc::CPropertyIndex columnToPropertyIndex(int column) const;
|
|
|
|
//! Index to property index
|
|
virtual BlackMisc::CPropertyIndex modelIndexToPropertyIndex(const QModelIndex &index) const
|
|
{
|
|
return this->columnToPropertyIndex(index.column());
|
|
}
|
|
|
|
//! Set sort column
|
|
virtual void setSortColumn(int column) { this->m_sortedColumn = column; }
|
|
|
|
/*!
|
|
* Set column for sorting
|
|
* \param propertyIndex index of column to be sorted
|
|
*/
|
|
virtual void setSortColumnByPropertyIndex(const BlackMisc::CPropertyIndex &propertyIndex)
|
|
{
|
|
this->m_sortedColumn = this->m_columns.propertyIndexToColumn(propertyIndex);
|
|
}
|
|
|
|
//! Get sort column property index
|
|
virtual int getSortColumn() const { return this->m_sortedColumn; }
|
|
|
|
//! Has valid sort column?
|
|
virtual bool hasValidSortColumn() const;
|
|
|
|
//! Get sort order
|
|
virtual Qt::SortOrder getSortOrder() const { return this->m_sortOrder; }
|
|
|
|
//! \copydoc QAbstractTableModel::flags
|
|
Qt::ItemFlags flags(const QModelIndex &index) const override;
|
|
|
|
//! Translation context
|
|
virtual const QString &getTranslationContext() const
|
|
{
|
|
return m_columns.getTranslationContext();
|
|
}
|
|
|
|
signals:
|
|
//! Asynchronous update finished
|
|
void asyncUpdateFinished();
|
|
|
|
//! Number of elements changed
|
|
void rowCountChanged(int count);
|
|
|
|
protected slots:
|
|
//! Helper method with template free signature
|
|
//! \param variant container is transferred in variant
|
|
//! \param sort
|
|
int updateContainer(const QVariant &variant, bool sort)
|
|
{
|
|
return this->performUpdateContainer(variant, sort);
|
|
}
|
|
|
|
protected:
|
|
/*!
|
|
* Constructor
|
|
* \param translationContext I18N context
|
|
* \param parent
|
|
*/
|
|
CListModelBaseNonTemplate(const QString &translationContext, QObject *parent = nullptr)
|
|
: QAbstractListModel(parent), m_columns(translationContext), m_sortedColumn(-1), m_sortOrder(Qt::AscendingOrder)
|
|
{
|
|
// non unique default name, set translation context as default
|
|
this->setObjectName(translationContext);
|
|
}
|
|
|
|
//! Helper method with template free signature
|
|
virtual int performUpdateContainer(const QVariant &variant, bool sort) = 0;
|
|
|
|
CColumns m_columns; //!< columns metadata
|
|
int m_sortedColumn; //!< current sort column
|
|
Qt::SortOrder m_sortOrder; //!< sort order (asc/desc)
|
|
};
|
|
|
|
/*!
|
|
* List model
|
|
*/
|
|
template <typename ObjectType, typename ContainerType> class CListModelBase :
|
|
public CListModelBaseNonTemplate
|
|
{
|
|
|
|
public:
|
|
//! Destructor
|
|
virtual ~CListModelBase() {}
|
|
|
|
//! Valid index (in range)
|
|
virtual bool isValidIndex(const QModelIndex &index) const;
|
|
|
|
//! Used container data
|
|
virtual const ContainerType &getContainer() const { return this->m_container; }
|
|
|
|
//! \copydoc QAbstractListModel::data()
|
|
virtual QVariant data(const QModelIndex &index, int role) const override;
|
|
|
|
//! \copydoc QAbstractListModel::rowCount()
|
|
virtual int rowCount(const QModelIndex &index = QModelIndex()) const override;
|
|
|
|
//! Update by new container
|
|
//! \remarks a sorting is performed only if a valid sort column is set
|
|
virtual int update(const ContainerType &container, bool sort = true);
|
|
|
|
//! Asynchronous update
|
|
//! \return worker or nullptr if worker could not be started
|
|
virtual BlackGui::IUpdateWorker *updateAsync(const ContainerType &container, bool sort = true);
|
|
|
|
//! Update by new container
|
|
virtual void updateContainerMaybeAsync(const ContainerType &container, bool sort = true);
|
|
|
|
//! Update single element
|
|
virtual void update(const QModelIndex &index, const ObjectType &object);
|
|
|
|
//! Update single element
|
|
virtual void update(int rowIndex, const ObjectType &object)
|
|
{
|
|
this->update(this->index(rowIndex), object);
|
|
}
|
|
|
|
//! Object at row position
|
|
virtual const ObjectType &at(const QModelIndex &index) const;
|
|
|
|
//! \copydoc QAbstractListModel::sort()
|
|
virtual void sort(int column, Qt::SortOrder order) override;
|
|
|
|
/*!
|
|
* Sort container by given column / order. This is used by sort() but als
|
|
* for asynchronous updates in the views
|
|
* \param container used list
|
|
* \param column column inder
|
|
* \param order sort order (ascending / descending)
|
|
* \threadsafe under normal conditions thread safe as long as the column metadata are not changed
|
|
*/
|
|
ContainerType sortContainerByColumn(const ContainerType &container, int column, Qt::SortOrder order) const;
|
|
|
|
//! Similar to ContainerType::push_back
|
|
virtual void push_back(const ObjectType &object);
|
|
|
|
//! Similar to ContainerType::insert here inserts at first position
|
|
virtual void insert(const ObjectType &object);
|
|
|
|
//! Remove object
|
|
virtual void remove(const ObjectType &object);
|
|
|
|
//! \copydoc ContainerBase::removeIf
|
|
template <class K0, class V0, class... KeysValues>
|
|
int removeIf(K0 k0, V0 v0, KeysValues... keysValues)
|
|
{
|
|
int c = m_container.removeIf(BlackMisc::Predicates::MemberEqual(k0, v0, keysValues...));
|
|
if (c > 0) { emit rowCountChanged(this->rowCount());}
|
|
return c;
|
|
}
|
|
|
|
//! Clear the list
|
|
virtual void clear();
|
|
|
|
protected:
|
|
ContainerType m_container; //!< used container
|
|
|
|
/*!
|
|
* Constructor
|
|
* \param translationContext I18N context
|
|
* \param parent
|
|
*/
|
|
CListModelBase(const QString &translationContext, QObject *parent = nullptr)
|
|
: CListModelBaseNonTemplate(translationContext, parent)
|
|
{ }
|
|
|
|
//! \copydoc CModelBaseNonTemplate::performUpdateContainer
|
|
virtual int performUpdateContainer(const QVariant &variant, bool sort) override;
|
|
|
|
// ---- worker -----------------------------------------------------------------------------------
|
|
|
|
//! Worker class performing update and sorting in background
|
|
class CModelUpdateWorker : public BlackGui::IUpdateWorker
|
|
{
|
|
|
|
public:
|
|
//! Constructor
|
|
CModelUpdateWorker(CListModelBase *model, const ContainerType &container, bool sort) :
|
|
BlackGui::IUpdateWorker(sort), m_model(model), m_container(container)
|
|
{
|
|
|
|
Q_ASSERT(model);
|
|
this->m_sortColumn = model->getSortColumn();
|
|
this->m_sortOrder = model->getSortOrder();
|
|
connect(this, &CModelUpdateWorker::updateFinished, model, &CListModelBase::asyncUpdateFinished, Qt::QueuedConnection);
|
|
this->setObjectName(model->objectName().append(":CModelUpdateWorker"));
|
|
}
|
|
|
|
//! Destructor
|
|
virtual ~CModelUpdateWorker() {}
|
|
|
|
protected:
|
|
//! \copydoc CUpdateWorkerPrivate::update
|
|
virtual void update() override
|
|
{
|
|
// KWB remove later
|
|
qDebug() << this->objectName() << "thread:" << QThread::currentThreadId();
|
|
if (m_model)
|
|
{
|
|
if (m_sort)
|
|
{
|
|
// almost thread safe sorting in background
|
|
m_container = m_model->sortContainerByColumn(m_container, m_sortColumn, m_sortOrder);
|
|
}
|
|
// now update model itself thread safe, but time for sort was saved
|
|
// the invoked method itself will run in the main thread's event loop again
|
|
QMetaObject::invokeMethod(m_model, "updateContainer", Qt::QueuedConnection,
|
|
Q_ARG(QVariant, m_container.toQVariant()), Q_ARG(bool, false));
|
|
}
|
|
}
|
|
|
|
CListModelBase *m_model = nullptr; //!< model to be updated, actually const but invokeMethod does not allow const
|
|
ContainerType m_container; //!< container with data
|
|
};
|
|
|
|
// ---- worker -----------------------------------------------------------------------------------
|
|
|
|
};
|
|
|
|
} // namespace
|
|
} // namespace
|
|
#endif // guard
|