text: #include "sortfilterproxymodel.h"
  #include <QtDebug>
  //#include <QtQml>
  #include <QByteArray>
  SortFilterProxyModel::SortFilterProxyModel(QObject *parent) : QSortFilterProxyModel(parent),
      m_complete(false)
  {
      connect(this, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SIGNAL(countChanged()));
      connect(this, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SIGNAL(countChanged()));
  }
  
  int SortFilterProxyModel::count() const
  {
      return rowCount();
  }
  
  QObject *SortFilterProxyModel::source() const
  {
      return sourceModel();
  }
  
  void SortFilterProxyModel::setSource(QObject *source)
  {
      setSourceModel(qobject_cast<QAbstractItemModel *>(source));
  }
  
  QByteArray SortFilterProxyModel::sortRole() const
  {
      return m_sortRole;
  }
  
  void SortFilterProxyModel::setSortRole(const QByteArray &role)
  {
      if (m_sortRole != role) {
          m_sortRole = role;
          if (m_complete)
              QSortFilterProxyModel::setSortRole(roleKey(role));
      }
  }
  
  QString SortFilterProxyModel::sortByRoleName() const
  {
      return m_sortByRoleName;
  }
  
  void SortFilterProxyModel::setSortByRoleName(const QString &sortByRoleName)
  {
      if (m_sortByRoleName != sortByRoleName) {
          m_sortByRoleName = sortByRoleName;
          QByteArray ba = sortByRoleName.toLatin1 ();
          if (ba != m_sortByRoleNameArray){
              m_sortByRoleNameArray = ba;
              if (m_complete)
                  QSortFilterProxyModel::setSortRole(roleKey(m_sortByRoleNameArray));
          }
      }
  }
  
  
  
  
  
  void SortFilterProxyModel::setSortOrder(Qt::SortOrder order)
  {
      QSortFilterProxyModel::sort(0, order);
  }
  
  QByteArray SortFilterProxyModel::filterRole() const
  {
      return m_filterRole;
  }
  
  void SortFilterProxyModel::setFilterRole(const QByteArray &role)
  {
      if (m_filterRole != role) {
          m_filterRole = role;
          if (m_complete)
              QSortFilterProxyModel::setFilterRole(roleKey(role));
      }
  }
  
  QString SortFilterProxyModel::filterString() const
  {
      return filterRegExp().pattern();
  }
  
  void SortFilterProxyModel::setFilterString(const QString &filter)
  {
      setFilterRegExp(QRegExp(filter, filterCaseSensitivity(),
                              static_cast<QRegExp::PatternSyntax>(filterSyntax())));
  }
  
  SortFilterProxyModel::FilterSyntax SortFilterProxyModel::filterSyntax() const
  {
      return static_cast<FilterSyntax>(filterRegExp().patternSyntax());
  }
  
  void SortFilterProxyModel::setFilterSyntax(SortFilterProxyModel::FilterSyntax syntax)
  {
      setFilterRegExp(QRegExp(filterString(), filterCaseSensitivity(), static_cast<QRegExp::PatternSyntax>(syntax)));
  }
  
  //QJSValue SortFilterProxyModel::get(int idx) const
  //{
  //    QJSEngine *engine = qmlEngine(this);
  //    QJSValue value = engine->newObject();
  //    if (idx >= 0 && idx < count()) {
  //        QHash<int, QByteArray> roles = roleNames();
  //        QHashIterator<int, QByteArray> it(roles);
  //        while (it.hasNext()) {
  //            it.next();
  //            value.setProperty(QString::fromUtf8(it.value()), data(index(idx, 0), it.key()).toString());
  //        }
  //    }
  //    return value;
  //}
  
  void SortFilterProxyModel::sortAgain(const QString &role, Qt::SortOrder order)
  {
      QSortFilterProxyModel::setSortRole ( sourceModel ()->roleNames().key( role.toLatin1() ));
      QSortFilterProxyModel::sort (0 ,order);
  }
  
  void SortFilterProxyModel::classBegin()
  {
  }
  
  void SortFilterProxyModel::componentComplete()
  {
      m_complete = true;
  
      if (!m_sortRole.isEmpty())
          QSortFilterProxyModel::setSortRole(roleKey(m_sortRole));
  
      if (!m_filterRole.isEmpty())
          QSortFilterProxyModel::setFilterRole(roleKey(m_filterRole));
  
      // FIXME this is not working for some reason
  //            when I set this is is not setting the roleName to sort by /.....
      if(!m_sortByRoleName.isEmpty ()){
          QByteArray mStringtoByte = m_sortByRoleName.toLatin1 ();
          QSortFilterProxyModel::setSortRole(roleKey(mStringtoByte));
      }
  }
  
  int SortFilterProxyModel::roleKey(const QByteArray &role) const
  {
      QHash<int, QByteArray> roles = roleNames();
      QHashIterator<int, QByteArray> it(roles);
      while (it.hasNext()) {
          it.next();
          if (it.value() == role)
              return it.key();
      }
      return -1;
  }
  
  QHash<int, QByteArray> SortFilterProxyModel::roleNames() const
  {
      if (QAbstractItemModel *source = sourceModel())
          return source->roleNames();
      return QHash<int, QByteArray>();
  }
  
  bool SortFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
  {
      QRegExp rx = filterRegExp();
      if (rx.isEmpty())
          return true;
      QAbstractItemModel *model = sourceModel();
      if (filterRole().isEmpty()) {
          QHash<int, QByteArray> roles = roleNames();
          QHashIterator<int, QByteArray> it(roles);
          while (it.hasNext()) {
              it.next();
              QModelIndex sourceIndex = model->index(sourceRow, 0, sourceParent);
              QString key = model->data(sourceIndex, it.key()).toString();
              if (key.contains(rx))
                  return true;
          }
          return false;
      }
      QModelIndex sourceIndex = model->index(sourceRow, 0, sourceParent);
      if (!sourceIndex.isValid())
          return true;
      QString key = model->data(sourceIndex, roleKey(filterRole())).toString();
      return key.contains(rx);
  }
  