¿Cómo puedo capturar QKeySequence de QKeyEvent dependiendo de la disposición actual del teclado?

Question

Necesito hacer esto para configurar mi aplicación. Tengo el campo QLineEdit con el método reimplementado keyPressEvent.

QKeyEvent *ke = ... 
QString txt; 

if(ke->modifiers() & Qt::ControlModifier) 
    txt += "Ctrl+"; 
if(ke->modifiers() & Qt::AltModifier) 
    txt += "Alt+"; 
if(ke->modifiers() & Qt::ShiftModifier) 
    txt += "Shift+"; 

if(ke->key() >= Qt::Key_0 && ke->key() <= Qt::Key_9) 
    txt += ('0' + ke->key() - Qt::Key_0); 
else if(ke->key() >= Qt::Key_A && ke->key() <= Qt::Key_Z) 
    txt += ('A' + ke->key() - Qt::Key_A); 
ui->hotkeyEdit->setText(txt); 

Pero esta solución solo puede crear accesos directos con caracteres en inglés. Por ejemplo, cuando uso el diseño del teclado ruso, este código mostrará la misma secuencia pero con el carácter inglés, colocado en la misma tecla del teclado.

Answer 1

Lo que puede resultarle muy útil es la función QKeySequance(). ToString().

La siguiente es una parte de un código que utilizo para captar los accesos directos definidos por el usuario. Con algunas modificaciones, puede hacer lo que necesite en su proyecto. Creo que sirve (lo siento por el identation Crapped):

if (event->type() == QEvent::KeyPress){ 
    QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event); 

    int keyInt = keyEvent->key(); 
    Qt::Key key = static_cast<Qt::Key>(keyInt); 
    if(key == Qt::Key_unknown){ 
     qDebug() << "Unknown key from a macro probably"; 
     return; 
    } 
    // the user have clicked just and only the special keys Ctrl, Shift, Alt, Meta. 
    if(key == Qt::Key_Control || 
     key == Qt::Key_Shift || 
     key == Qt::Key_Alt || 
     key == Qt::Key_Meta) 
    { 
     qDebug() << "Single click of special key: Ctrl, Shift, Alt or Meta"; 
     qDebug() << "New KeySequence:" << QKeySequence(keyInt).toString(QKeySequence::NativeText); 
     return; 
    } 

    // check for a combination of user clicks 
    Qt::KeyboardModifiers modifiers = keyEvent->modifiers(); 
    QString keyText = keyEvent->text(); 
    // if the keyText is empty than it's a special key like F1, F5, ... 
    qDebug() << "Pressed Key:" << keyText; 

    QList<Qt::Key> modifiersList; 
    if(modifiers & Qt::ShiftModifier) 
     keyInt += Qt::SHIFT; 
    if(modifiers & Qt::ControlModifier) 
     keyInt += Qt::CTRL; 
    if(modifiers & Qt::AltModifier) 
     keyInt += Qt::ALT; 
    if(modifiers & Qt::MetaModifier) 
     keyInt += Qt::META; 

    qDebug() << "New KeySequence:" << QKeySequence(keyInt).toString(QKeySequence::NativeText); 
} 

Answer 2

Prefiero un standard seqence.

Desde el Keyboard Layout Issues:

Como resultado, ambas cadenas legibles y códigos de teclas codificadas de forma rígida pueden ser ambos problemático utilizar cuando se especifica una secuencia de teclas que se pueden utilizar en una variedad de diferente teclado diseños. Solo el uso de accesos directos estándar garantiza que el usuario podrá usar los accesos directos que pretendía el desarrollador.

Answer 3

Puede asignar atajos de teclado a las acciones.

Aquí hay maneras de hacerlo.

actionName->setShortcut(QKeySequence::New); //for predefined shortcuts like new, close, open.. 

o puede definir su propio acceso directo con este

actionName->setShortcut(QKeySequence("Ctrl+N")); // sets Ctrl + N for w.e the action does 

En el primer caso, detecta y asigna el acceso directo apropiado para esa acción en particular qt automáticamente. En el segundo caso, puede elegir su propio atajo deseado y escribirlo como una cadena. Lo analiza y lo entiende automáticamente.

Esto evita la necesidad de utilizar capturas de teclas para fines innecesarios.

Answer 4

Si alguien se preocupa por la versión pitón de la solución de Tihomir Dolapchiev anteriormente. Acabo de traducirlo y funciona genial. Solo publicando para futuras referencias.

class KeySequenceEdit(QtGui.QLineEdit): 
    """ 
    This class is mainly inspired by 
    http://stackoverflow.com/a/6665017 

    """ 

    def __init__(self, keySequence, *args): 
     super(KeySequenceEdit, self).__init__(*args) 

     self.keySequence = keySequence 
     self.setKeySequence(keySequence) 

    def setKeySequence(self, keySequence): 
     self.keySequence = keySequence 
     self.setText(self.keySequence.toString(QtGui.QKeySequence.NativeText)) 


    def keyPressEvent(self, e): 
     if e.type() == QtCore.QEvent.KeyPress: 
      key = e.key() 

      if key == QtCore.Qt.Key_unknown: 
       warnings.warn("Unknown key from a macro probably") 
       return 

      # the user have clicked just and only the special keys Ctrl, Shift, Alt, Meta. 
      if(key == QtCore.Qt.Key_Control or 
      key == QtCore.Qt.Key_Shift or 
      key == QtCore.Qt.Key_Alt or 
      key == QtCore.Qt.Key_Meta): 
       print("Single click of special key: Ctrl, Shift, Alt or Meta") 
       print("New KeySequence:", QtGui.QKeySequence(key).toString(QtGui.QKeySequence.NativeText)) 
       return 

      # check for a combination of user clicks 
      modifiers = e.modifiers() 
      keyText = e.text() 
      # if the keyText is empty than it's a special key like F1, F5, ... 
      print("Pressed Key:", keyText) 

      if modifiers & QtCore.Qt.ShiftModifier: 
       key += QtCore.Qt.SHIFT 
      if modifiers & QtCore.Qt.ControlModifier: 
       key += QtCore.Qt.CTRL 
      if modifiers & QtCore.Qt.AltModifier: 
       key += QtCore.Qt.ALT 
      if modifiers & QtCore.Qt.MetaModifier: 
       key += QtCore.Qt.META 

      print("New KeySequence:", QtGui.QKeySequence(key).toString(QtGui.QKeySequence.NativeText)) 

      self.setKeySequence(QtGui.QKeySequence(key)) 

Answer 5

manera más simple es:

if(event->type() == QEvent::KeyPress) 
{ 
    QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event); 
    qDebug() << "delete" << keyEvent->matches(QKeySequence::Delete); 
    qDebug() << "copy" << keyEvent->matches(QKeySequence::Copy); 
    qDebug() << "paste" << keyEvent->matches(QKeySequence::Paste); 
}