En esta página

Ejemplo de modelo de ordenación y filtrado personalizados

El ejemplo de modelo de ordenación y filtrado personalizados ilustra cómo crear una subclase de ` QSortFilterProxyModel ` para realizar operaciones avanzadas de ordenación y filtrado.

Captura de pantalla del ejemplo de modelo de ordenación y filtrado personalizados

La clase ` QSortFilterProxyModel ` permite ordenar y filtrar los datos que se transmiten entre otro modelo y una vista.

El modelo transforma la estructura de un modelo de origen asignando los índices del modelo que proporciona a nuevos índices, correspondientes a diferentes ubicaciones, para que los utilicen las vistas. Este enfoque permite reestructurar un modelo de origen determinado en lo que respecta a las vistas, sin necesidad de realizar transformaciones en los datos subyacentes y sin duplicar los datos en la memoria.

El ejemplo «Modelo personalizado de ordenación y filtrado» consta de dos clases:

  • La clase « MySortFilterProxyModel » proporciona un modelo proxy personalizado.
  • La clase « Window » proporciona la ventana principal de la aplicación, utilizando el modelo proxy personalizado para ordenar y filtrar un modelo de elementos estándar.

En primer lugar, analizaremos la clase ` MySortFilterProxyModel ` para ver cómo se implementa el modelo proxy personalizado; a continuación, analizaremos la clase ` Window ` para ver cómo se utiliza el modelo. Por último, echaremos un vistazo rápido a la función ` main() `.

Definición de la clase MySortFilterProxyModel

La clase ` MySortFilterProxyModel ` hereda de la clase ` QSortFilterProxyModel `.

Dado que QAbstractProxyModel y sus subclases derivan de QAbstractItemModel, gran parte de los consejos sobre la subclasificación de modelos normales también se aplican a los modelos proxy.

Por otro lado, cabe señalar que muchas de las implementaciones predeterminadas de las funciones de ` QSortFilterProxyModel` están escritas de tal forma que llaman a las funciones equivalentes del modelo de origen correspondiente. Es posible que sea necesario anular este sencillo mecanismo de proxy en el caso de modelos de origen con un comportamiento más complejo. En este ejemplo, heredamos de la clase QSortFilterProxyModel para garantizar que nuestro filtro pueda reconocer un intervalo válido de fechas y para controlar el comportamiento de ordenación.

class MySortFilterProxyModel : public QSortFilterProxyModel
{
    Q_OBJECT

public:
    MySortFilterProxyModel(QObject *parent = nullptr);

    QDate filterMinimumDate() const { return minDate; }
    void setFilterMinimumDate(QDate date);

    QDate filterMaximumDate() const { return maxDate; }
    void setFilterMaximumDate(QDate date);

protected:
    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
    bool lessThan(const QModelIndex &left, const QModelIndex &right) const override;

private:
    bool dateInRange(QDate date) const;

    QDate minDate;
    QDate maxDate;
};

Queremos poder filtrar nuestros datos especificando un periodo de tiempo determinado. Por ese motivo, implementamos las funciones personalizadas ` setFilterMinimumDate() ` y ` setFilterMaximumDate() `, así como las funciones correspondientes ` filterMinimumDate() ` y ` filterMaximumDate() `. Reimplementamos la función filterAcceptsRow() de QSortFilterProxyModel para que solo acepte filas con fechas válidas, y QSortFilterProxyModel::lessThan() para poder ordenar los remitentes por sus direcciones de correo electrónico. Por último, implementamos una función de conveniencia dateInRange() que utilizaremos para determinar si una fecha es válida.

Implementación de la clase `MySortFilterProxyModel`

El constructor de MySortFilterProxyModel es muy sencillo: pasa el parámetro «parent» al constructor de la clase base:

MySortFilterProxyModel::MySortFilterProxyModel(QObject *parent)
    : QSortFilterProxyModel(parent)
{
}

Las partes más interesantes de la implementación de MySortFilterProxyModel son las reimplementaciones de las funciones filterAcceptsRow() y lessThan() de QSortFilterProxyModel. Echemos primero un vistazo a nuestra función personalizada lessThan().

bool MySortFilterProxyModel::lessThan(const QModelIndex &left,
                                      const QModelIndex &right) const
{
    QVariant leftData = sourceModel()->data(left);
    QVariant rightData = sourceModel()->data(right);

Queremos ordenar los remitentes por sus direcciones de correo electrónico. La función lessThan() se utiliza como operador < al ordenar. La implementación predeterminada admite una colección de tipos que incluyen QDateTime y String, pero para poder ordenar los remitentes por sus direcciones de correo electrónico, primero debemos identificar la dirección dentro de la cadena dada:

    if (leftData.userType() == QMetaType::QDateTime)
        return leftData.toDateTime() < rightData.toDateTime();

    static const QRegularExpression emailPattern(u"[\\w\\.]*@[\\w\\.]*"_s);

    QString leftString = leftData.toString();
    if (left.column() == 1) {
        const QRegularExpressionMatch match = emailPattern.match(leftString);
        if (match.hasMatch())
            leftString = match.captured(0);
    }
    QString rightString = rightData.toString();
    if (right.column() == 1) {
        const QRegularExpressionMatch match = emailPattern.match(rightString);
        if (match.hasMatch())
            rightString = match.captured(0);
    }

    return QString::localeAwareCompare(leftString, rightString) < 0;
}

Utilizamos ` QRegularExpression ` para definir un patrón para las direcciones que buscamos. La función ` match()` devuelve un objeto ` QRegularExpressionMatch ` que contiene el resultado de la coincidencia. Si hay una coincidencia, ` hasMatch()` devuelve `true`. El resultado de la coincidencia se puede recuperar mediante la función ` captured()` de ` QRegularExpressionMatch`. La coincidencia completa tiene el índice 0 y las subexpresiones entre paréntesis tienen índices que comienzan a partir de 1 (excluyendo los paréntesis que no capturan).

bool MySortFilterProxyModel::filterAcceptsRow(int sourceRow,
                                              const QModelIndex &sourceParent) const
{
    QModelIndex index0 = sourceModel()->index(sourceRow, 0, sourceParent);
    QModelIndex index1 = sourceModel()->index(sourceRow, 1, sourceParent);
    QModelIndex index2 = sourceModel()->index(sourceRow, 2, sourceParent);

    return (sourceModel()->data(index0).toString().contains(filterRegularExpression())
            || sourceModel()->data(index1).toString().contains(filterRegularExpression()))
            && dateInRange(sourceModel()->data(index2).toDate());
}

Por otro lado, se espera que la función filterAcceptsRow() devuelva «true» si la fila dada debe incluirse en el modelo. En nuestro ejemplo, se acepta una fila si el asunto o el remitente contienen la expresión regular dada y la fecha es válida.

bool MySortFilterProxyModel::dateInRange(QDate date) const
{
    return (!minDate.isValid() || date > minDate)
            && (!maxDate.isValid() || date < maxDate);
}

Utilizamos nuestra función personalizada ` dateInRange() ` para determinar si una fecha es válida.

Para poder filtrar nuestros datos especificando un periodo de tiempo determinado, también implementamos funciones para obtener y establecer las fechas mínima y máxima:

void MySortFilterProxyModel::setFilterMinimumDate(QDate date)
{
    beginFilterChange();
    minDate = date;
    endFilterChange(QSortFilterProxyModel::Direction::Rows);
}

void MySortFilterProxyModel::setFilterMaximumDate(QDate date)
{
    beginFilterChange();
    maxDate = date;
    endFilterChange(QSortFilterProxyModel::Direction::Rows);
}

Las funciones de obtención, ` filterMinimumDate() ` y ` filterMaximumDate()`, son sencillas y se implementan como funciones en línea en el archivo de cabecera.

Con esto queda completado nuestro modelo de proxy personalizado. Veamos cómo podemos utilizarlo en una aplicación.

Definición de la clase Window

La clase ` CustomFilter ` hereda de ` QWidget` y proporciona la ventana principal de la aplicación de este ejemplo:

class Window : public QWidget
{
    Q_OBJECT

public:
    Window();

    void setSourceModel(QAbstractItemModel *model);

private slots:
    void textFilterChanged();
    void dateFilterChanged();

private:
    MySortFilterProxyModel *proxyModel;

    QTreeView *sourceView;
    QTreeView *proxyView;
    FilterWidget *filterWidget;
    QDateEdit *fromDateEdit;
    QDateEdit *toDateEdit;
};

Implementamos dos slots privados, ` textFilterChanged() ` y ` dateFilterChanged()`, para responder a los cambios que realice el usuario en el patrón de filtro, la distinción entre mayúsculas y minúsculas o cualquiera de las fechas. Además, implementamos una función de conveniencia pública ` setSourceModel() ` para configurar la relación entre el modelo y la vista.

Implementación de la clase de ventana

En este ejemplo, hemos optado por crear y configurar el modelo de origen en la función main () (a la que volveremos más adelante). Así pues, al construir la ventana principal de la aplicación, damos por hecho que ya existe un modelo de origen y comenzamos creando una instancia de nuestro modelo proxy personalizado:

Window::Window()
    : proxyModel(new MySortFilterProxyModel(this)),

Configuramos la propiedad ` dynamicSortFilter `, que determina si el modelo proxy se ordena y filtra dinámicamente. Al establecer esta propiedad en `true`, nos aseguramos de que el modelo se ordene y filtre cada vez que cambie el contenido del modelo de origen.

La ventana principal de la aplicación muestra vistas tanto del modelo de origen como del modelo proxy. La vista de origen es bastante sencilla:

sourceView->setRootIsDecorated(false);
sourceView->setAlternatingRowColors(true);

La clase ` QTreeView ` proporciona una implementación predeterminada de modelo/vista de una vista en árbol. Nuestra vista implementa una representación en árbol de los elementos del modelo de origen de la aplicación.

auto *sourceGroupBox = new QGroupBox(tr("Original Model"));
auto *sourceLayout = new QHBoxLayout(sourceGroupBox);
sourceLayout->addWidget(sourceView);

La clase ` QTreeView ` proporciona una implementación predeterminada de modelo/vista de una vista en árbol; nuestra vista implementa una representación en árbol de los elementos del modelo de origen de la aplicación. Añadimos nuestro widget de vista a un diseño que instalamos en un cuadro de grupo correspondiente.

La vista del modelo proxy, por su parte, contiene varios widgets que controlan los distintos aspectos de la transformación de la estructura de datos del modelo de origen:

filterWidget->setText(tr("Grace|Sports"));
fromDateEdit->setDate(QDate(1970, 01, 01));
toDateEdit->setDate(QDate(2099, 12, 31));

Tenga en cuenta que, cada vez que el usuario cambie una de las opciones de filtrado, debemos volver a aplicar el filtro de forma explícita. Esto se consigue conectando los distintos editores a funciones que actualizan el modelo proxy.

connect(filterWidget, &FilterWidget::filterChanged,
        this, &Window::textFilterChanged);
connect(filterWidget, &QLineEdit::textChanged,
        this, &Window::textFilterChanged);
connect(fromDateEdit, &QDateTimeEdit::dateChanged,
        this, &Window::dateFilterChanged);
connect(toDateEdit, &QDateTimeEdit::dateChanged,
        this, &Window::dateFilterChanged);

La ordenación la gestionará la vista. Lo único que tenemos que hacer es habilitar la ordenación para nuestra vista proxy configurando la propiedad « QTreeView::sortingEnabled » (que está en «false» por defecto). A continuación, añadimos todos los widgets de filtrado y la vista proxy a un diseño que instalamos en el cuadro de grupo correspondiente.

proxyView->setRootIsDecorated(false);
proxyView->setAlternatingRowColors(true);
proxyView->setModel(proxyModel);
proxyView->setSortingEnabled(true);
proxyView->sortByColumn(1, Qt::AscendingOrder);

auto *proxyGroupBox = new QGroupBox(tr("Sorted/Filtered Model"));
auto *proxyLayout = new QVBoxLayout(proxyGroupBox);
proxyLayout->addWidget(proxyView);
auto *formLayout = new QFormLayout;
proxyLayout->addLayout(formLayout);
formLayout->addRow(tr("&Filter pattern:"), filterWidget);
formLayout->addRow(tr("F&rom:"), fromDateEdit);
formLayout->addRow(tr("&To:"), toDateEdit);

Por último, tras colocar nuestros dos cuadros de grupo en otro diseño que instalamos en el widget principal de nuestra aplicación, personalizamos la ventana de la aplicación.

    auto *mainLayout = new QVBoxLayout(this);
    mainLayout->addWidget(sourceGroupBox);
    mainLayout->addWidget(proxyGroupBox);

    setWindowTitle(tr("Custom Sort/Filter Model"));
    auto screenGeometry = screen()->geometry();
    resize(screenGeometry.width() / 2, screenGeometry.height() * 2 / 3);
}

Como se ha mencionado anteriormente, creamos el modelo de origen en la función ` main ()`, llamando a la función ` Window::setSourceModel() ` para que la aplicación lo utilice:

void Window::setSourceModel(QAbstractItemModel *model)
{
    proxyModel->setSourceModel(model);
    sourceView->setModel(model);

    for (int i = 0; i < proxyModel->columnCount(); ++i)
        proxyView->resizeColumnToContents(i);
    for (int i = 0; i < model->columnCount(); ++i)
        sourceView->resizeColumnToContents(i);
}

La función ` QSortFilterProxyModel::setSourceModel()` hace que el modelo proxy procese los datos del modelo dado, en este caso nuestro modelo de correo. La función ` setModel()`, que el widget de vista hereda de la clase ` QAbstractItemModel `, establece el modelo que la vista debe presentar. Ten en cuenta que esta última función también creará y establecerá un nuevo modelo de selección.

void Window::textFilterChanged()
{
    FilterWidget::PatternSyntax s = filterWidget->patternSyntax();
    QString pattern = filterWidget->text();
    switch (s) {
    case FilterWidget::Wildcard:
        pattern = QRegularExpression::wildcardToRegularExpression(pattern);
        break;
    case FilterWidget::FixedString:
        pattern = QRegularExpression::escape(pattern);
        break;
    default:
        break;
    }

    QRegularExpression::PatternOptions options = QRegularExpression::NoPatternOption;
    if (filterWidget->caseSensitivity() == Qt::CaseInsensitive)
        options |= QRegularExpression::CaseInsensitiveOption;
    QRegularExpression regularExpression(pattern, options);
    proxyModel->setFilterRegularExpression(regularExpression);
}

La función ` textFilterChanged() ` se invoca cada vez que el usuario cambia el patrón de filtro o la distinción entre mayúsculas y minúsculas.

En primer lugar, recuperamos la sintaxis preferida (se utiliza la enumeración `FilterWidget::PatternSyntax` para interpretar el significado del patrón dado) y, a continuación, determinamos la distinción entre mayúsculas y minúsculas preferida. En función de estas preferencias y del patrón de filtro actual, establecemos la propiedad ` filterRegularExpression ` del modelo proxy. La propiedad ` filterRegularExpression ` contiene la expresión regular utilizada para filtrar el contenido del modelo de origen. Ten en cuenta que al llamar a la función ` setFilterRegularExpression()` de ` QSortFilterProxyModel` también se actualiza el modelo.

void Window::dateFilterChanged()
{
    proxyModel->setFilterMinimumDate(fromDateEdit->date());
    proxyModel->setFilterMaximumDate(toDateEdit->date());
}

La función dateFilterChanged() se invoca cada vez que el usuario modifica el rango de fechas válidas. Recuperamos las nuevas fechas de la interfaz de usuario e invocamos las funciones correspondientes (proporcionadas por nuestro modelo proxy personalizado) para establecer las fechas mínima y máxima del modelo proxy. Como hemos explicado anteriormente, la invocación de estas funciones también actualiza el modelo.

La función Main()

En este ejemplo, hemos separado la aplicación del modelo fuente creando el modelo en la función main (). Primero creamos la aplicación y, a continuación, creamos el modelo fuente:

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    Window window;
    window.setSourceModel(new MailModel(&window));
    window.show();
    return QApplication::exec();
}

Creamos una clase ` MailModel`, que hereda de ` QRangeModel ` y reimplementa `QAbstractItemView::headerData()` para devolver los encabezados de sección correctos. Se rellena a partir de una matriz de estructuras ` MailHeader`. ` MailHeader ` se declara como una ` Q_GADGET ` con propiedades que utilizará ` QRangeModel`:

struct MailHeader
{
private:
    Q_GADGET
    Q_PROPERTY(QString subject MEMBER subject)
    Q_PROPERTY(QString sender MEMBER sender)
    Q_PROPERTY(QDateTime date MEMBER date)

public:
    QString subject;
    QString sender;
    QDateTime date;
};
class MailModel : public QRangeModel
{
public:
    explicit MailModel(QObject *parent = nullptr) : QRangeModel(mails, parent) {}

    QVariant headerData(int section, Qt::Orientation orientation,
                        int role = Qt::DisplayRole) const override
    {
        if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
            switch (section) {
            case 0:
                return Window::tr("Subject");
            case 1:
                return Window::tr("Sender");
            case 2:
                return Window::tr("Date");
            default:
                break;
            }
        }
        return QRangeModel::headerData(section, orientation, role);
    }

private:
    static const std::array<MailHeader, 10> mails;
};

const std::array<MailHeader, 10> MailModel::mails = {
    MailHeader{ u"RE: Sports"_s, u"Petra Schmidt <petras@nospam.com>"_s,
                QDateTime(QDate(2007, 01, 05), QTime(12, 01)) },
    MailHeader{ u"AW: Sports"_s, u"Rolf Newschweinstein <rolfn@nospam.com>"_s,
                QDateTime(QDate(2007, 01, 05), QTime(12, 00)) },
    MailHeader{ u"Sports"_s, u"Linda Smith <linda.smith@nospam.com>"_s,
                QDateTime(QDate(2007, 01, 05), QTime(11, 33)) },
    MailHeader{ u"Re: Accounts"_s, u"Andy <andy@nospam.com>"_s,
                QDateTime(QDate(2007, 01, 03), QTime(14, 26)) },
    MailHeader{ u"Re: Accounts"_s, u"Joe Bloggs <joe@bloggs.com>"_s,
                QDateTime(QDate(2007, 01, 03), QTime(14, 18)) },
    MailHeader{ u"Re: Expenses"_s, u"Andy <andy@nospam.com>"_s,
                QDateTime(QDate(2007, 01, 02), QTime(16, 05)) },
    MailHeader{ u"Expenses"_s, u"Joe Bloggs <joe@bloggs.com>"_s,
                QDateTime(QDate(2006, 12, 25), QTime(11, 39)) },
    MailHeader{ u"Accounts"_s, u"pascale@nospam.com"_s,
                QDateTime(QDate(2006, 12, 31), QTime(12, 50)) },
    MailHeader{ u"Radically new concept"_s, u"Grace K. <grace@software-inc.com>"_s,
                QDateTime(QDate(2006, 12, 22), QTime(9, 44)) },
    MailHeader{ u"Happy New Year!"_s, u"Grace K. <grace@software-inc.com>"_s,
                QDateTime(QDate(2006, 12, 31), QTime(17, 03)) }
};

Proyecto de ejemplo en code.qt.io

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.