[SOLUCIONADO] Qt. Cómo evitar el modo de edición al avanzar con Tab

[dehm]

Bueno, la pregunta es la siguiente:

Si tengo una QTableView y edito una celda, y luego me sigo moviendo con la techa Tab, entro en modo de edición en la siguiente celda, y me gustaría que saliese del modo de edición al cambiar de celda. Más o menos como ocurre con una hoja de cálculo.

Saludos y gracias!

[eferion]

QTableView debería tener un método llamado setTabKeyNavitagion que acepta un booleano:

• true para que tab permita pasar de una celda a la siguiente
• false para que tab entre en modo edición

[dehm]

Hola eferion:

He probado así, pero creo que no es lo que realmente busco.
Si está en true (por defecto), cuando he editado una celda pasa a la celda de la derecha en modo edición. Si está en false, para al siguiente widget de mi programa (un editor de textos en este caso)

Pero a mi me gustaría que pasara a la celda contigua sin modo de edición. No sé si será cuestión de definir su comportamiento por medio de QKeyEvent. A ver si a lo largo del día puedo hacer una prueba.

[eferion]

Efectivamente. Para esa funcionalidad tienes que interceptar la pulsación del tabulador.

Esto lo puedes hacer heredando la tabla o mediante un filtro de eventos. Yo personalmente te recomendaría esta segunda opción:

Código C++:

class Filter : public QObject
{
  Q_OBJECT;
 
  public:
 
    bool eventFilter(QObject *object, QEvent *event) override;
 
};
 
bool Filter::eventFilter(QObject *object, QEvent *event)
{
  QTableView* table = dynamic_cast<QTableView*>(object);
  if( !table ) return false;
 
  if (event->type() == QEvent::KeyPress)
  {
    QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
    if (keyEvent->key() == Qt::Key_Tab)
    {
      QModelIndex current = table->currentIndex();
      if( current.column() != table->model()->columnCount() )
      {
        QModelIndex newIndex = table->model()->index(current.row(),current.column()+1);
        table->selectionModel()->select(newIndex,QItemSelectionModel::ClearAndSelect);
        return true;
      }
    }
  }
  return false;
}
 

Y para usarlo:

Código C++:

Filter* filter = new Filter;
QTableView* table /* ... */;
table->installEventFilter(filter);
 

[dehm]

Hola eferion:
Gracias por responder. He tardado un poco en responder yo, porque hasta ayer no me pude poner a ver el ejemplo. La cosa es que no funcionaba, y por si acaso, he repetido el ejemplo con una tabla sencilla, recien creada, no con la que estoy trabajando...y tampoco.

Cuando estoy en modo de edición, el evento no se captura, y salto de celda en celda en modo edición siempre.
Si estoy fuera del modo de edición, entonces sí que se captura el tabulador. (en este caso me aparece la info que me da qDebug de la posición de cada fila y columna.Además, he de posicionarme en la celda actual y le he añadido una línea a tu código).

Código C++:

bool Filter::eventFilter(QObject *object, QEvent *event)
{
    QTableView* table = dynamic_cast<QTableView*>(object);
    if( !table ) return false;
 
    if (event->type() == QEvent::KeyPress)
    {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
        if (keyEvent->key() == Qt::Key_Tab)
        {
            QModelIndex current = table->currentIndex();
            if( current.column() != table->model()->columnCount() )
            {
                QModelIndex newIndex = table->model()->index(current.row(),current.column()+1);
                qDebug()<<newIndex.row()<<"<--->"<<newIndex.column();//para saber la posicion
                table->selectionModel()->select(newIndex,QItemSelectionModel::ClearAndSelect);
                table->setCurrentIndex(newIndex);//para posicionarme en la nueva celda
                return true;
            }
        }
    }
    return false;
}
 

El ejemplo completo (es sólo una tabla y un modelo que lee de un array)
filter.h

Código C++:

#ifndef FILTER_H
#define FILTER_H
 
#include <QObject>
#include <QTableView>
#include <QEvent>
#include <QKeyEvent>
#include <QDebug>
 
class Filter : public QObject
{
    Q_OBJECT
public:
    explicit Filter(QObject *parent = 0);
    bool eventFilter(QObject *object, QEvent *event) override;
 
signals:
 
public slots:
};
 
#endif // FILTER_H
 

filter.cpp

Código C++:

#include "filter.h"
 
Filter::Filter(QObject *parent) : QObject(parent)
{
 
}
 
bool Filter::eventFilter(QObject *object, QEvent *event)
{
    QTableView* table = dynamic_cast<QTableView*>(object);
    if( !table ) return false;
 
    if (event->type() == QEvent::KeyPress)
    {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
        if (keyEvent->key() == Qt::Key_Tab)
        {
            QModelIndex current = table->currentIndex();
            if( current.column() != table->model()->columnCount() )
            {
                QModelIndex newIndex = table->model()->index(current.row(),current.column()+1);
                qDebug()<<newIndex.row()<<"<--->"<<newIndex.column();
                table->selectionModel()->select(newIndex,QItemSelectionModel::ClearAndSelect);
                table->setCurrentIndex(newIndex);
                return true;
            }
        }
    }
    return false;
}
 

el modelo:

Código C++:

#ifndef MIMODELO_H
#define MIMODELO_H
 
#include <QObject>
#include <QAbstractTableModel>
 
const int FILAS = 5;
const int COLUMNAS = 5;
 
class MiModelo : public QAbstractTableModel
{
public:
 
    MiModelo();
 
    int rowCount(const QModelIndex& parent) const;
    int columnCount(const QModelIndex& parent) const;
    QVariant headerData(int section, Qt::Orientation orientation, int role) const;
    QVariant data(const QModelIndex& indice,int role = Qt::DisplayRole) const;
    Qt::ItemFlags flags(const QModelIndex &index) const;
    bool setData(const QModelIndex & index, const QVariant& value, int role);
 
private:
    int valores[FILAS][COLUMNAS];
};
 
#endif // MIMODELO_H
 

Código C++:

#include "mimodelo.h"
 
MiModelo::MiModelo()
{
    for (int i=0;i<FILAS;i++)
    {
        for (int j=0;j<COLUMNAS;j++)
        {
            valores[i][j]=0;
        }
    }
 
}
 
int MiModelo::rowCount(const QModelIndex& parent) const
{
    return FILAS;
}
 
int MiModelo::columnCount(const QModelIndex& parent) const
{
    return COLUMNAS;
}
 
QVariant MiModelo::headerData(int section, Qt::Orientation orientation, int role) const
{
    return QVariant();
}
 
QVariant MiModelo::data(const QModelIndex& indice,int role) const
{
    if (!indice.isValid()) return QVariant();
 
    if (role==Qt::DisplayRole || role == Qt::EditRole)
    {
        return valores[indice.row()][indice.column()];
    }
    return QVariant();
}
 
Qt::ItemFlags MiModelo::flags(const QModelIndex &index) const
{
    if (!index.isValid())
    {
        return 0;
    }
    else return QAbstractTableModel::flags(index) | Qt::ItemIsEditable;
}
 
bool MiModelo::setData(const QModelIndex & index, const QVariant& value, int role)
{
    if (index.isValid() && (role == Qt::EditRole || role == Qt::DisplayRole))
    {
        valores[index.row()][index.column()]= value.toInt();
        emit dataChanged(index, index);
        return true;
    }
    return false;
}
 

y por último el widget:

Código C++:

#ifndef WIDGET_H
#define WIDGET_H
 
#include <QWidget>
 
#include "mimodelo.h"
#include "filter.h"
 
namespace Ui {
class Widget;
}
 
class Widget : public QWidget
{
    Q_OBJECT
 
public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();
 
private:
    Ui::Widget *ui;
    MiModelo* _model;
    Filter* filter;
};
 
#endif // WIDGET_H
 

Código C++:

#include "widget.h"
#include "ui_widget.h"
 
Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);
    _model =  new MiModelo;
    ui->tableView->setModel(_model);
 
    filter = new Filter;
    ui->tableView->installEventFilter(filter);
}
 
Widget::~Widget()
{
    delete ui;
}
 

Saludos y gracias!

[eferion]

Si estás en modo edición no es la tabla la que recibe el evento sino el widget de edición.

Tendrías que editar la generación de los widgets de edición para insertar el filtro de eventos en dicho widget.

[dehm]

Bueno, pues no lo consigo.

He creado un delegado para las celdas.
En la función createEditor() he añadido el filtro de eventos:

Código C++:

QWidget* MiDelegado::createEditor(QWidget * parent, const QStyleOptionViewItem & option, const QModelIndex & index) const
{
    const QAbstractItemModel* model = index.model();
    if (!model)
    {
        return QStyledItemDelegate::createEditor(parent,option,index);
    }
    QLineEdit* miEditor = new QLineEdit(parent);
    QRegExpValidator* validadorEdad = new QRegExpValidator(QRegExp("[0-9.,]{1,10}"),miEditor);
    miEditor->setValidator(validadorEdad);
    miEditor->setAlignment(Qt::AlignLeft);
    miEditor->installEventFilter(filter);
    return miEditor;
}
 

Pero ahora, cuando estoy con el filtro de eventos, veo que responde a todas las pulsaciones de teclas menos a la del tabulador, y ahí me he quedado...

Código C++:

bool Filter::eventFilter(QObject *object, QEvent *event)
{   
    QLineEdit *editor = dynamic_cast<QLineEdit*>(object);
    if (!editor)
    {
        return false;
    }
    if (event->type() == QEvent::KeyPress)
    {
        QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
        qDebug()<<event->type();
 
        if (keyEvent->key() == Qt::Key_Tab)
        {
            qDebug()<<"Tab";
            //QModelIndex current = editor->parent()->objectName();
            //qDebug()<<editor->parent()->objectName();
 
            //qDebug()<<editor->parent()->objectName();
 
            return true;
        }
    }
    return false;
}
 

Es curioso porque es la única tecla que no considera

[dehm]

Por otro lado, creo que el evento FocusOut podría valer, ya que es independiente de la tecla pulsada, pero tengo otro problema, y es que no sé cómo acceder a la tabla desde el editor.
¿Puede ser que el editor no sea hijo de la tabla siempre, o es que yo lo he hecho mal y no he ligado el editor a la tabla?

Al usar el evento, me sale que el nombre del padre es "qt_scrollarea_viewport"

Código C++:

if (event->type() == QEvent::FocusOut)
    {
        qDebug()<<editor->parent()->objectName();
...............
 

[eferion]

El problema que tienes es que no sabes cómo funciona la edición por debajo.

Al editar una celda lo que sucede es que se crea un widget que, por defecto, se va a superponer a la celda a editar, de tal forma que al usuario le da la impresión de que está escribiendo sobre la propia celda... pero no es así. Dicho widget de edición se carga dentro de un contenedor que es ese viewport que comentas.

En cuanto al tema del tabulador en edición, yo probaría a hacer algo tal que:

Código C++:

void MiDelegado::closeEditor(QWidget* editor, QAbstractItemDelegate::EndEditHint hint)
{
  if (hint == QAbstractItemDelegate::EditNextItem && currentColumn() == 1)
    hint = QAbstractItemDelegate::EditPreviousItem;
  else if (hint == QAbstractItemDelegate::EditPreviousItem && currentColumn() == 0)
    hint = QAbstractItemDelegate::EditNextItem;
  [ClaseBase]::closeEditor(editor, hint); // Sustuir [ClaseBase]
}
 

[dehm]

Hola eferion, sabía como funcionaban los delegados....porque ya me lo habías explicado , lo que pasa es que cuando no me salen las cosas uno acaba sin saber dónde tiene la cara.

Bueno, lo he "solucionado" pero no estoy nada convencido de que esta sea una solución decente.
Al menos he podido delegar los eventos en los delegados (nunca mejor dicho) pero necesito conectar la señal closeEditor() a la tabla.

En realidad lo que he hecho es capturar la tecla Tab en el editor del delegado, cuyas consecuencias son actualizar el dato de la celda y cerrar el editor

Código C++:

commitData(mieditor);
closeEditor(mieditor);
 

Por otro lado, he conectado la señal closeEditor a un slot que se encarga de mover el índice actual de la tabla. No parece un diseño muy aceptable

En fin, este sería el código de lo que he hecho finalmente (la implementación está incompleta pero todo parece pensar que va a funcionar)

en el delegado:

Código C++:

bool MiDelegado::eventFilter(QObject * editor, QEvent * event)
{
    if (!editor)
    {
        return false;
    }
    if (event->type() == QEvent::KeyPress)
    {
        QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
        if (keyEvent->key() == Qt::Key_Tab)
        {
            QLineEdit* mieditor = dynamic_cast<QLineEdit*>(editor);
            commitData(mieditor);
            closeEditor(mieditor);
            return true;
        }
    }
    return false;
}
 

La conexión SIGNAL/SLOT

Código C++:

QObject::connect(delegado,SIGNAL(closeEditor(QWidget*,QAbstractItemDelegate::EndEditHint)),this,SLOT(Posicionar()));
 

Y el código del SLOT (incompleto)

Código C++:

void Widget::Posicionar()
{
    QModelIndex current = ui->tableView->currentIndex();
    qDebug()<<current.row()<<"<-->"<<current.column();
    if (current.column()<ui->tableView->model()->columnCount(QModelIndex()))
    {
        QModelIndex newIndex = ui->tableView->model()->index(current.row(),current.column()+1);
        ui->tableView->setCurrentIndex(newIndex);
    }
}
 

[dehm]

Bueno, como sospechaba, esta solución está lejos de ser válida, ya que sólo me contempla el caso de pulsar la tecla Tab, y no podría (o al menos de forma sencilla) definir el comportamiento de BackTab o Return, por ejemplo.

Por otro lado el ejemplo que me has puesto, de redefinir la señal de closeEditor tampoco me funciona.

[eferion]

¿Has probado lo que te he comentado en mi última respuesta?

[dehm]

Iniciado por eferion

¿Has probado lo que te he comentado en mi última respuesta?

Si. Ya te comentaba que el definir la función closeEditor no me ha funcionado.
Aunque también es verdad que no he sabido de dónde sale la función currentColumn() y no se me ocurrió otra cosa que quitarlo de la condición:

Esto es lo que puse (que no me funcionó):

Código Python:

void MiDelegado::closeEditor(QWidget* editor, QAbstractItemDelegate::EndEditHint hint)
{
    qDebug()<<"Cerrando el editor";
    if (hint == QAbstractItemDelegate::EditNextItem /*&& currentColumn() == 1*/)
        hint = QAbstractItemDelegate::EditNextItem;
      else if (hint == QAbstractItemDelegate::EditPreviousItem /*&& currentColumn() == 0*/)
        hint = QAbstractItemDelegate::EditNextItem;
      QAbstractItemDelegate::closeEditor(editor, hint);
}
 

Por otro lado al leer en la ayuda:
"The hint provides a way for the delegate to influence how the model and view behave after editing is completed. It indicates to these components what action should be performed next to provide a comfortable editing experience for the user. For example, if EditNextItem is specified, the view should use a delegate to open an editor on the next item in the model."

pensé que no era este el camino correcto, ya que parece que precisamente el hint EditNextItem lo que hace es abrir el siguiente widget en modo de edición. Pero vamos, que estoy hecho un lío

edito: creo que no lo he traducido bien, entonces lo que dice es que "si se especifica EditNextItem, la vista debería usar un delegado para abrir un editor en el siguiente item del modelo"
(pero aún así, me he quedado igual)

[eferion]

Es decir, tu lo que quieres es que si estás en modo edición y presionas el tabulador que se salga del modo edición y salte a la siguiente celda... pero sin editarla. ¿cierto?

[dehm]

Iniciado por eferion

Es decir, tu lo que quieres es que si estás en modo edición y presionas el tabulador que se salga del modo edición y salte a la siguiente celda... pero sin editarla. ¿cierto?

Eso es

[dehm]

Bueno, pues parece que definitivamente he resuelto el problema.
La cosa está en crear el filtro de eventos para el delegado en cuestión. En mi caso, el delegado es simplemente un QLineEdit. Este filtro de eventos captura la tecla Tab y lo que hace es mandar las señales de cerrar el editor y enviar los datos.
Respecto al envío de la señal de cerrar el editor, es importante que no ponga en modo Edit el siguiente delegado:(QStyledItemDelegate::NoHint)

Además es importante que en caso de que se pulse la tecla deseada, retorne false. Esto permite a la tabla hacer uso de dicho evento (la pulsación de la tecla Tab en este caso será leída también por la tabla...o el widget que sea).

Aquí está la implementación de la función en la clase de mi delegado (que es una clase heredada de QStyledItemDelegate):

Código C++:

bool DelegadoNombre::eventFilter(QObject *obj, QEvent* event)
{
    if (event->type()==QEvent::KeyPress)
    {
        QKeyEvent* key = static_cast<QKeyEvent*>(event);
        if (key->key()==Qt::Key_Tab || key->key()==Qt::Key_Enter || key->key()==Qt::Key_Return)
        {
            QLineEdit *editor=qobject_cast<QLineEdit*>(obj);
            emit commitData(editor);
            emit closeEditor(editor, QStyledItemDelegate::NoHint);
        }
        else
        {
            return QObject::eventFilter(obj, event);
        }
        return false;
    }
    else
    {
        return QObject::eventFilter(obj, event);
    }
    return false;
}
 

Resumiendo, lo que estoy haciendo al pulsar Tab es cerrar el editor por medio de la señal closeEditor() especificando que no abra el siguiente, y pasar dicha pulsación dela tecla Tab a la tabla para que la gestione si es el caso.

[eferion]

Celebro que hayas encontrado la respuesta. He estado ausente con eso de que se acababa el año y no te he podido prestar más asistencia.

Un saludo.

[dehm]

Iniciado por eferion

Celebro que hayas encontrado la respuesta. He estado ausente con eso de que se acababa el año y no te he podido prestar más asistencia.

Un saludo.

La clave me la diste tú. Realmente mi aportación ha sido poca en la solución

Mi mayor problema es poder dedicarle tiempo a esto. Ahora en vacaciones lo retomo, pero no suelo disponer de un día o una mañana entera para poder avanzar como quisiera