C++ (Qt)
setSelectionBehavior(QAbstractItemView::SelectRows);
setSelectionMode(QAbstractItemView::ExtendedSelection);
 

C++ (Qt)
 
Qt::ItemFlags MyTableModel::flags(const QModelIndex &index) const
{
    if (!index.isValid())
        return Qt::NoItemFlags;
 
    return QAbstractTableModel::flags(index) | Qt::ItemIsSelectable;
 
}
 

C++ (Qt)
void  TreeView::mousePressEvent(QMouseEvent *e)
{
    if(e->modifiers() & Qt::Controlmodifier)
   {
       QModelIndex idx = indexAt(e->pos());
 
       QModelIndex topLeft = model()->index(idx.row(), 0, QModelIndex());
       QModelIndex bottomRight = model()->index(idx.row(), model()->columnCount() - 1, QModelIndex());
 
       QItemSelection selection(topLeft, bottomRight);
       selectionModel()->select(selection, QItemSelectionModel::Select);
   }
 
   return QTreeView::mousePressEvent(e);
}
 

C++ (Qt)
 
void container::add_mapping(Key key, Type &value)
{
    std::lock_guard<std::mutex> l(mutex);
    auto it = unordered_map.find(key);
    if(it == unordered_map.end()){
           Type *data = new Type;
           unordered_map.insert(std::make_pair(key, data));
           vectror.push_back(data);     
    } 
    else{
          *(it.operator->()->second) = value;
    }
 
}
 
std::vector<Type> container::get_vector()
{
       std::lock_guard<std::mutex> l(mutex);
       std::vector<Type> v;
       for(auto e : vector){
            v.push_back(*e);
       }      
       return v;
}
 

void Model::update(std::vector<Type> &fresh)
{
    int prvsz = store.size();
    int cursz = fresh.size();
 
    beginInsertRows(QModelIndex(), prvsz, cursz);
    store.swap(fresh);
    endInsertRows();
}

C++ (Qt)
 
void Model::upDate(std::vector<typedata> &fresh, QTreeview *view)
{
 
  int prvsz = v.size();
  int cursz = fresh.size();
  int count = cursz - prvsz;
 
 if (count>0) {
 
      beginInsertRows(QModelIndex(), prvsz, cursz - 1);
      v.swap(fresh);
      endInsertRows();
 }
 else if(count==0){   
  QRect viewportRect = view->viewport()->rect();
 
  QModelIndex topLeft = view->indexAt(viewportRect.topLeft());
  QModelIndex bottomRight = view->indexAt(viewportRect.bottomRight());
 
   if(topLeft.isValid() && bottomRight.isValid()){
        dataChanged(topLeft,bottomRight);
    }
 }
 else {
 
  beginInsertRows(QModelIndex(), cursz , prvsz - 1);
  v.swap(fresh);
  endInsertRows();
 }
  }
 
 

C++ (Qt)
class Model : public ...
{
private:
  std::vector<Type> store;
}
 
void Model::update(std::vector<Type> &fresh)
{
    int prvsz = store.size();
    int cursz = fresh.size();
 
    beginInsertRows(QModelIndex(), prvsz, cursz);
    store.swap(fresh);
    endInsertRows();
}
 

C++ (Qt)
Widget::Widget(...) : ...
{
   model = new TableModel(..., this);
   sort = new SortFilterProxyModel(this);
   sort->setSourceModel(model);
   treeview = new TreeView(this);
   treeview->setModel(sort);
}
 

C++ (Qt)
void Widget::updateModel()
{
 
      int cursz = v.size();      
      int prvsz = wgtvec.size();
      int count = cursz- prvsz;
 
      if(count > 0){
 
         std::vector<Type> v = threadsafe_unordered_map.getVector();        
         model->update(v);
 
       }
       else if(count == 0){
 
         QRect viewportRect = tableView->viewport()->rect();
 
         QModelIndex topLeft = tableView->indexAt(viewportRect.topLeft());
         QModelIndex bottomRight = tableView->indexAt(viewportRect.bottomRight());
 
          if(topLeft.isValid() && bottomRight.isValid()){
 
               model->dataChanged(topLeft,bottomRight);
 
         }
       } 
}
 

sort->dataChanged(...)

C++ (Qt)
std::mutex m;
std::unordered_map<Key, std::shared_ptr<T>> map;
std::deque<shared_ptr<T>> q;
 

C++ (Qt)
 
beginInsertRows( QModelIndex(), prvsz, cursz);
 
wgtvec.swap(v);
 
endInsertRows();
 

C++ (Qt)
 
class Widget : public QWidget
{
 ...
 
private:
  std::vector<std::pair<Key, Type>> wgtvec;
  Table *model;
}
 
Widget::Widget(...) : ...
{
 
   model = new TableModel(&wgtvec);
}
 
void Widget::updateModel()
{
      //запрашиваем вектор с данными
      std::vector<std::pair<Key, Type>> v = threadsafe_unordered_map.getVector();      
 
      int cursz = v.size();      
      int prvsz = wgtvec.size();
      int count = cursz- prvsz;
 
      if(count > 0){
             wgtvec.swap(v);         
             beginInsertRows( QModelIndex(), prvsz, cursz);
             endInsertRows();
         }
       }
       else if(count == 0){
 
         QRect viewportRect = tableView->viewport()->rect();
 
         QModelIndex topLeft = tableView->indexAt(viewportRect.topLeft());
         QModelIndex bottomRight = tableView->indexAt(viewportRect.bottomRight());
 
          if(topLeft.isValid() && bottomRight.isValid()){
 
               model->dataChanged(topLeft,bottomRight);
 
         }
 
       } 
}
 

C++ (Qt)
class TableView : public QTableView 
{
...
public:
    int numberRows;
}
 
 
bool TableView::viewportEvent(QEvent *event)
{
 if(event->type == QEvent::Paint){
 
   int hrow = rowHeight(0);
 
   if(hrow > 0){
      numberRows = viewport()->size().height() / hrow
  }
  else{
    numberRows = 1;
  }
 
  return QTableView::viewportEvent(event);
 
}
 

C++ (Qt)
 
std::vector<std::pair<Key, Type>> Core::GetTableData(int pos, nrows)
{
    std::vector<std::pair<Key, Type>> v = threadsafe_unordered_map.get_vecctor();
    std::vector<std::pair<Key, Type>> res;
 
    for(int i = 0; i < nrows; ++i)
   {       
      std::pair<Key, Type> p = v[pos + i];
      res.push_back(p);
   }
 
    return res;
}
 

C++ (Qt)
 
class MainWindow : public QMainWindow
{
 
private:
 std::vector<std::pair<Key, Type>> v;
 
}
 
MainWindow::MainWindow(...)
{
   ...
   model = new TableModel(&v, this)
}
 
void MainWindow::UpDateTable()
{
    v =  core.GetTableData(ui->verticalScroll->sliderPosition(), ui->tableView->numberRows);
    model->upDate(); //beginResetModel() endResetModel()
}
 

C++ (Qt)
TableModel::TableModel(std::vector<std::pair<uint32_t, uint32_t>> *v_ , QObject *parent)
    : QAbstractTableModel(parent)
{
    v = v_;
}
 
 
void TableModel::upDate()
{
    beginResetModel();
    endResetModel();
}
 
 
QVariant TableModel::data(const QModelIndex &index, int role) const
{
    if(!index.isValid() || v->size() == 0){
        return QVariant();
    }else{
        switch(role){
        case Qt::DisplayRole: {
            switch(index.column()){
 
            case 0 :{
                return v->at(index.row()).first;
            }
 
            case 1:{
                return v->at(index.row()).second;
            }
 
            default:
                return QVariant();
            }
        }
        case Qt::TextAlignmentRole:{
            return Qt::AlignCenter;
        }
        case Qt::FontRole: {
            QFont f;
            f.setFamily("monospace");
            f.setStyleHint(QFont::Monospace);
            return f;
        }
        default:
            return QVariant();
        }
    }
}