Qt中QSortFilterProxyModel关于多列排序的实现

       在以前也使用过QSortFilterProxyModel这个类， 用它对视图进行搜索，排序等操作还是比较方便的。但是发现在排序时只允许根据一个关键字来排序，如果要实现“先根据列A升序，在根据列B降序排序”的这种需求，它就无能为力了。在网上查找关于这方面的信息或代码，发现都是有这种需求，但没有现成的例子可以借鉴。无奈之下，自行研究了Qt这个代理类的实现和源代码，找出了实现多个关键组排序的方法，在此发布给大家共享。

       首先，QSortFilterProxyModel有个虚函数叫lessThan，用于比较两个值的大小。通过查看文档和源代码可知，排序的比较操作都是通过这个虚函数来完成的，那么意味着只要重新实现这个虚函数，就可以实现按自己想要的任何方式来排序了，当然也包括按多个关键字段来排序。

       从QSortFilterProxyModel类继承一个新类，在该类中定义一个类型MultiColumnOrder表示多关键字段的排序方式定义：

typedef QList<QPair<int, Qt::SortOrder> > MultiColumnOrder;

QList内的QPair类型表示一个排序字段的信息，整数为字段的列号，Qt::SortOrder定义了排序方式是升序还是降序。

private:
    MultiColumnOrder m_orders;

public:
    // set column orders
    void setMultiColumnOrders(const MultiColumnOrder& orders);

    // return defined column orders
    MultiColumnOrder multiColumnOrder() const;

protected:
    // \reimp
    virtual bool lessThan ( const QModelIndex & left, const QModelIndex & right ) const;

然后定义一个私有变量来保存排序字段表，和属性的读写函数。最后就是重载lessThan函数了。在这个函数里，需要对left和right两行数据依次对每个关键字排序字段进行比较，如果相等，则继续进行下一个排序字段比较，直到不相等或者所有字段比较完成。具体的实现大概如下：

// \reimp
bool MultiColSortProxyModel::lessThan ( const QModelIndex & left,
                                        const QModelIndex & right ) const
{
    QPair<int, Qt::SortOrder> colorder;
    int c;
    QVariant l, r;
    QModelIndex idxLeft, idxRight;
    // loop for all ordered columns
    foreach(colorder, m_orders)
    {
        c = colorder.first;
        idxLeft = left.model()->index(left.row(), c, left.parent());
        idxRight = right.model()->index(right.row(), c, right.parent());

        // read value
        if (colorder.second==Qt::AscendingOrder)
        {
            // compare l<r while Ascending
            l = idxLeft.data(sortRole());
            r = idxRight.data(sortRole());
        }
        else
        {
            // compare r<l while Descending
            r = idxLeft.data(sortRole());
            l = idxRight.data(sortRole());
        }

        switch (l.userType())
        {
        case QVariant::Invalid:
            return (r.type() == QVariant::Invalid);
        case QVariant::Int:
            if (l.toInt() < r.toInt())
                return true;
            else if (l.toInt() > r.toInt())
                return false;
            break;
        case QVariant::UInt:
            if (l.toUInt() < r.toUInt())
                return true;
            else if (l.toUInt() > r.toUInt())
                return false;
            break;
        case QVariant::LongLong:
            if (l.toLongLong() < r.toLongLong())
                return true;
            else if (l.toLongLong() > r.toLongLong())
                return false;
            break;
        case QVariant::ULongLong:
            if (l.toULongLong() < r.toULongLong())
                return true;
            else if (l.toULongLong() > r.toULongLong())
                return false;
            break;
        case QMetaType::Float:
            if (l.toFloat() < r.toFloat())
                return true;
            else if (l.toFloat() > r.toFloat())
                return false;
            break;
        case QVariant::Double:
            if (l.toDouble() < r.toDouble())
                return true;
            else if (l.toDouble() > r.toDouble())
                return false;
            break;
        case QVariant::Char:
            if (l.toChar() < r.toChar())
                return true;
            else if (l.toChar() > r.toChar())
                return false;
            break;
        case QVariant::Date:
            if (l.toDate() < r.toDate())
                return true;
            else if (l.toDate() > r.toDate())
                return false;
            break;
        case QVariant::Time:
            if (l.toTime() < r.toTime())
                return true;
            else if (l.toTime() > r.toTime())
                return false;
            break;
        case QVariant::DateTime:
            if (l.toDateTime() < r.toDateTime())
                return true;
            else if (l.toDateTime() > r.toDateTime())
                return false;
            break;
        case QVariant::String:
        default:
            if (isSortLocaleAware())
            {
                c = l.toString().localeAwareCompare(r.toString());
                if (c<0)
                    return true;
                else if (c>0)
                    return false;
            }
            else
            {
                c = l.toString().compare(r.toString(), sortCaseSensitivity());
                if (c<0)
                    return true;
                else if (c>0)
                    return false;
            }
        }
    }

    // all key column value are equals
    return true;
}    

用这个代理类即可很好的实现按多个关键字段排序。以上为个人拙见，有任何建议和问题请指正。