13:37 Mot de passe oublié ?

180

Tiens, nouveau problème lors de l'établissement d'une connexion entre un QPushButton et une méthode non-statique de ma MainWindow :StartPage::StartPage(QWidget *parent) : QWidget(parent), ui(new Ui::StartPage) { ui->setupUi(this); connect(ui->buttonNewGame, &QPushButton::clicked, mainwindow, &MainWindow::newGame); }mainwindow est une variable globale, qui pointe sur ma MainWindow classique. Elle est initialisée dans main().
Et ça crashe dans qobject.h :
        return connectImpl(sender, reinterpret_cast<void **>(&signal),
                           receiver, reinterpret_cast<void **>(&slot),
                           new QtPrivate::QSlotObject<Func2, typename QtPrivate::List_Left<typename SignalType::Arguments, SlotType::ArgumentCount>::Value,
                                           typename SignalType::ReturnType>(slot),
                            type, types, &SignalType::Object::staticMetaObject);
Ca compile sans problème, mais ça segfault à la connexion. Comme le code me parait tout à fait lambda, je sais pas vers où chercher sad

edit -> Bon, j'ai résoudru le problème avec un singleton pour MainWindow, mais sans savoir pourquoi ça déconnait avant sad

181

Je suppose que ton initialisation dans main est de ce type:
MainWindow *mainwindow = new MainWindow();et que ton code tournait à l'intérieur du constructeur de MainWindow (puisqu'il se trouve dans le constructeur de StartPage), donc avant l'initialisation (à quoi devrait-il initialiser ce pointeur si l'objet n'est pas encore construit?).
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

182

Yep, c'était bien ça le problème, d'ailleurs j'ai dû initialiser mon pointeur statique d'instance dans le constructeur de MainWindow, et non dans le get() statique habituel, vu que des objets du constructeur avaient besoin de l'instance, en effet.
Bien vu. smile

183

Un article intéressant, je sais plus où j'avais posé la question de savoir s'il valait mieux allouer ses dialogues sur la pile ou le tas. La réponse : https://blogs.kde.org/2009/03/26/how-crash-almost-every-qtkde-application-and-how-fix-it-0
Donc ni l'un ni l'autre, il faut utiliser un QPointer.

184

Qu'utiliser comme widget pour faire du dessin rudimentaire, ie tracer des points ou des lignes à la souris ? Vous êtes tous sur le même pied d'égalité pour répondre à ça, mais Kevin est quand même bien plus égal que vous donc je le call :
Commande call : Kevin Kofler appelé(e) sur ce topic

185

Ah, j'oubliais : j'ai vu http://doc.qt.io/qt-5/qgraphicsscene.html
Ca pourrait êtres une base, mais est-qu'il y a quelque chose qui dérive de QWidget et qui fournit quelque chose de ce genre, comme dans KolourPaint ?

186

Tu dérives directement de QWidget, ou de QFrame si tu veux avoir un joli bord autour de ce que tu dessines, et tu surcharges le paintEvent. Comme tu n'es pas censé dessiner quoi que ce soit en dehors du paintEvent, tu stockes tout ce que tu veux dessiner dans une QQueue et tu appelles update() juste après (ou repaint() si tu veux qu'il redessine immédiatement, sans attendre la boucle d'évènements), et ton paintEvent dessine le contenu de ta QQueue dans l'ordre.
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

187

Merci, super réponse ! top

188

KolourPaint utilise un widget spécial, KpView: https://quickgit.kde.org/?p=kolourpaint.git&a=tree&f=views
Il dessine dans un QPixmap contenu dans un KpDocument, et KpView affiche à partir de ce pixmap.
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

189

Je te demandais pas d'aller crawler dans le code de KolourPaint, mais merci de l'avoir fait. J'y ai bien pensé, mais en quelques heures, j'aurais probablement pas eu l'info grin

190

Bah, comme tu vois, ça m'a pris 5 minutes.
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

191

Je veux écrire des données dans un fichier. J'utilise QFile et QDataStream.
Ca, ce n'est pas un problème.

Mais je voudrais que mon fichier commence par un marqueur (une sorte d'ACK) écrit à la fin de la transaction. Y a-t-il un moyen de faire un "rewind" du stream, ou quelque chose d'assimilé ? Merci à tous. tripo

Question subsidiaire : une écriture via l'opérateur << renvoie une référence au QDataStream utilisé. Comment savoir si l'écriture a réussi ?

192

Salut Folco. Pour le succès d'une écriture, tu peux utiliser la méthode QDataStream::status. Et la prochaine fois, lis la doc avant de poser des questions à la con.

193

Folco (./191) :
Mais je voudrais que mon fichier commence par un marqueur (une sorte d'ACK) écrit à la fin de la transaction. Y a-t-il un moyen de faire un "rewind" du stream, ou quelque chose d'assimilé ?
Tu peux utiliser pos et seek sur le QIODevice en dessous.
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

194

Ah, merci beaucoup, j'ai pas pensé à regarder la classe parent. smile

195

Nouvelle question Qt-esque :
Je veux traduire une touche Qt::Key ( http://doc.qt.io/qt-5/qt.html#Key-enum ) en touche native Windows.
Est-ce que les méthodes nativeModifiers/ScanCode/VirtualKey de la classe QKeyEvent font ce boulot ? J'aimerais quand même le savoir avant de rédiger ma propre table...
Les source ne m'ont pas beaucoup aidé...

Merci bien. smile

edit -> bon ben je suis exactement dans ce cas-là, traduire un QKeySequence en keycode natif : http://www.archivum.info/qt-interest@trolltech.com/2007-08/00888/Re-Windows-Virtual-Key-code-from-QKeyEvent.html
Solution, piocher dans vergogne dans le kernel de Qt couic

re-edit -> et même là, toujours rien : http://code.qt.io/cgit/qt/qtbase.git/tree/src/gui/kernel sad

196

Folco (./195) :
Nouvelle question Qt-esque :
Je veux traduire une touche Qt::Key ( http://doc.qt.io/qt-5/qt.html#Key-enum ) en touche native Windows.
Est-ce que les méthodes nativeModifiers/ScanCode/VirtualKey de la classe QKeyEvent font ce boulot ? J'aimerais quand même le savoir avant de rédiger ma propre table...
Ces méthodes te donnent bien les codes natifs, mais seulement si le QKeyEvent provient du système. Si tu l'as construit avec le constructeur qui prend seulement la touche Qt, alors les native* seront tous 0.
re-edit -> et même là, toujours rien : http://code.qt.io/cgit/qt/qtbase.git/tree/src/gui/kernel sad
Ça a été déplacé dans le plugin plateforme: http://code.qt.io/cgit/qt/qtbase.git/tree/src/plugins/platforms/windows/qwindowskeymapper.cpp
avatar
Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

197

Ok, merci pour l'explication. Ca semble logique en effet, pour le QKeyEvent.
Et merci de m'avoir retrouvé le mapping dans le source, j'ai pourtant passé du temps hier dans le dépôt, sans succès

198

Bon ben voilà, ça donne ça, pas encore testé mais ça devrait aller :
KeyTranslator.hpp
#ifndef KEYTRANSLATOR_HPP #define KEYTRANSLATOR_HPP #include <QObject> class KeyTranslator { public: KeyTranslator(); static bool isRegisterable(int key); static void translateKey(int key, unsigned int* modifiers, unsigned int* virtualKey); private: Q_DISABLE_COPY(KeyTranslator) static int TranslationTable[][2]; }; #endif // KEYTRANSLATOR_HPP
KeyTranslator.cpp
#include "KeyTranslator.hpp" #include "windows.h" #define SupportedModifiersMask 0x1E000000 // Support Shirt, Control, Alt and Meta #define QtAllModifiersMask 0x7E000000 // All Qt modifiers #define QtKeysMask 0x01FFFFFF // All Qt keys without modifiers KeyTranslator::KeyTranslator() { } // Check if a Qt key is translatable bool KeyTranslator::isRegisterable(int key) { // Check for valid modifiers if ((key & QtAllModifiersMask) != 0) { return false; } // Try to find a matching key key &= QtKeysMask; for (int i = 0; TranslationTable[i][0] != Qt::Key_unknown; i++) { if (TranslationTable[i][0] == key) { return true; } } return false; } // Translate a Qt key into Windows modifiers and virtual key. The key must be translatable void KeyTranslator::translateKey(int key, unsigned int* modifiers, unsigned int* virtualKey) { // Read modifiers unsigned qtModifiers = key &SupportedModifiersMask; // Set the MOD_NOREPEAT bit. FIXME: where is defined this macro? *modifiers = 0x4000; if (qtModifiers & Qt::ShiftModifier) { *modifiers |= MOD_SHIFT; } if (qtModifiers & Qt::ControlModifier) { *modifiers |= MOD_CONTROL; } if (qtModifiers & Qt::AltModifier) { *modifiers |= MOD_ALT; } if (qtModifiers & Qt::MetaModifier) { *modifiers |= MOD_WIN; } // Read key int qtKey = key & QtKeysMask; *virtualKey = Qt::Key_unknown; // Safety for (int i = 0; TranslationTable[i][0] != Qt::Key_unknown; i++) { if (qtKey == TranslationTable[i][0]) { *virtualKey = TranslationTable[i][1]; break; } } } // Doc used: // http://code.qt.io/cgit/qt/qtbase.git/tree/src/plugins/platforms/windows/qwindowskeymapper.cpp // https://msdn.microsoft.com/fr-fr/library/windows/desktop/dd375731(v=vs.85).aspx int KeyTranslator::TranslationTable[][2] = { 0x01000000, VK_ESCAPE, // Qt::Key_Escape 0x01000001, VK_TAB, // Qt::Key_Tab 0x01000003, VK_BACK, // Qt::Key_Backspace 0x01000004, VK_RETURN, // Qt::Key_Return 0x01000005, VK_RETURN, // Qt::Key_Enter 0x01000006, VK_INSERT, // Qt::Key_Insert 0x01000007, VK_DELETE, // Qt::Key_Delete 0x01000008, VK_PAUSE, // Qt::Key_Pause 0x01000009, VK_PRINT, // Qt::Key_Print 0x0100000a, VK_SNAPSHOT, // Qt::Key_SysReq 0x0100000b, VK_CLEAR, // Qt::Key_Clear 0x01000010, VK_HOME, // Qt::Key_Home 0x01000011, VK_END, // Qt::Key_End 0x01000012, VK_LEFT, // Qt::Key_Left 0x01000013, VK_UP, // Qt::Key_Up 0x01000014, VK_RIGHT, // Qt::Key_Right 0x01000015, VK_DOWN, // Qt::Key_Down 0x01000016, VK_PRIOR, // Qt::Key_PageUp 0x01000017, VK_NEXT, // Qt::Key_PageDown 0x01000024, VK_CAPITAL, // Qt::Key_CapsLock 0x01000025, VK_NUMLOCK, // Qt::Key_NumLock 0x01000026, VK_SCROLL, // Qt::Key_ScrollLock 0x01000030, VK_F1, // Qt::Key_F1 0x01000031, VK_F2, // Qt::Key_F2 0x01000032, VK_F3, // Qt::Key_F3 0x01000033, VK_F4, // Qt::Key_F4 0x01000034, VK_F5, // Qt::Key_F5 0x01000035, VK_F6, // Qt::Key_F6 0x01000036, VK_F7, // Qt::Key_F7 0x01000037, VK_F8, // Qt::Key_F8 0x01000038, VK_F9, // Qt::Key_F9 0x01000039, VK_F10, // Qt::Key_F10 0x0100003a, VK_F11, // Qt::Key_F11 0x0100003b, VK_F12, // Qt::Key_F12 0x0100003c, VK_F13, // Qt::Key_F13 0x0100003d, VK_F14, // Qt::Key_F14 0x0100003e, VK_F15, // Qt::Key_F15 0x0100003f, VK_F16, // Qt::Key_F16 0x01000040, VK_F17, // Qt::Key_F17 0x01000041, VK_F18, // Qt::Key_F18 0x01000042, VK_F19, // Qt::Key_F19 0x01000043, VK_F20, // Qt::Key_F20 0x01000044, VK_F21, // Qt::Key_F21 0x01000045, VK_F22, // Qt::Key_F22 0x01000046, VK_F23, // Qt::Key_F23 0x01000047, VK_F24, // Qt::Key_F24 0x01000055, VK_RMENU, // Qt::Key_Menu 0x01000058, VK_HELP, // Qt::Key_Help 0x20 , VK_SPACE, // Qt::Key_Space 0x30 , 0x30, // Qt::Key_0 0x31 , 0x31, // Qt::Key_1 0x32 , 0x32, // Qt::Key_2 0x33 , 0x33, // Qt::Key_3 0x34 , 0x34, // Qt::Key_4 0x35 , 0x35, // Qt::Key_5 0x36 , 0x36, // Qt::Key_6 0x37 , 0x37, // Qt::Key_7 0x38 , 0x38, // Qt::Key_8 0x39 , 0x39, // Qt::Key_9 0x41 , 0x41, // Qt::Key_A 0x42 , 0x42, // Qt::Key_B 0x43 , 0x43, // Qt::Key_C 0x44 , 0x44, // Qt::Key_D 0x45 , 0x45, // Qt::Key_E 0x46 , 0x46, // Qt::Key_F 0x47 , 0x47, // Qt::Key_G 0x48 , 0x48, // Qt::Key_H 0x49 , 0x49, // Qt::Key_I 0x4a , 0x4A, // Qt::Key_J 0x4b , 0x4B, // Qt::Key_K 0x4c , 0x4C, // Qt::Key_L 0x4d , 0x4D, // Qt::Key_M 0x4e , 0x4E, // Qt::Key_N 0x4f , 0x4F, // Qt::Key_O 0x50 , 0x50, // Qt::Key_P 0x51 , 0x51, // Qt::Key_Q 0x52 , 0x52, // Qt::Key_R 0x53 , 0x53, // Qt::Key_S 0x54 , 0x54, // Qt::Key_T 0x55 , 0x55, // Qt::Key_U 0x5a , 0x5A, // Qt::Key_Z 0x56 , 0x56, // Qt::Key_V 0x57 , 0x57, // Qt::Key_W 0x58 , 0x58, // Qt::Key_X 0x59 , 0x59, // Qt::Key_Y Qt::Key_unknown, 0x00 // Qt::Key_unknown. Mark the end of the table };

Le problème des "keys" fournies par Qt, c'est qu'elles sont déjà transformées en fonction du clavier physique etc, et c'est donc très dut de récupérer le virtual code natif. La flemme de faire la reverse translation de toutes les touches, et je ne suis même pas sûr d'y arriver

199

Tu peux prendre le problème par un autre bout : intercepter le message natif avant que Qt le traite, et ainsi avoir accès au virtual key code d'origine. Ce n'est certes pas très propre, mais faire une table de conversion inverse non plus... (et ça permet de gérer les raccourcis avec les touches "supplémentaires" des claviers, genre les touches multimédia, ce qui ne permettra sans doute pas la méthode Qt vu que ces touches ne sont pas toutes standardisées)
avatar
— Zeroblog —

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

200

Putain, il me suffit d'intercepter l'event Qt lors de la saisie du raccourci en effet !!!!!!!!!!!!!!!! En espérant que ça fonctionne avec ce widget un peu spécial love
C'est donc ici que ça se passe : http://doc.qt.io/qt-5/qobject.html#installEventFilter
Zerosquare, si ça marche, je débarque chez toi et je te roule une pelle dont tu te souviendras longtemps lovelovelovelovelovelovelovelovelovelove

201

Pour la dernière fois : à moins que tu sois devenu japonaise depuis la dernière fois qu'on s'est vus, je me vois obligé de décliner, toute généreuse qu'elle soit ^^
avatar
— Zeroblog —

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

202

cheeky

Soit la doc suivante sur les modifiers de Windows : https://msdn.microsoft.com/fr-fr/library/windows/desktop/ms646309
Soit la doc suivante sur les évènements claviers de Qt : http://doc.qt.io/qt-5/qkeyevent.html#public-functions

Soit le code suivant, du niveau CE1-CE2 :
#include <windows.h>
...
quint32 modifiers = keyEvent->nativeModifiers() & 0x000F; // Clear possible MOD_NOREPEAT ?
...
        // Display the name of the pressed modifiers
        if ((modifiers & MOD_CONTROL) != 0) {
            buttonText += tr("Ctrl + ");
        }
        if ((modifiers & MOD_ALT) != 0) {
            buttonText += tr("Alt + ");
        }
        if ((modifiers & MOD_SHIFT) != 0) {
            buttonText += tr("Shift + ");
        }
Le code est donc censé afficher une combinaison de "Ctrl + ", "Alt + ", "Shift + " dans un bouton, c'est très basique.
Résultat :
- quand j'appuie sur Alt, le bouton affiche Alt +
- quand j'appuie sur Ctrl, le bouton affiche Shift +
- quand j'appuie sur Shift, le bouton affiche Ctrl +
- Shift droit, AltGr et Ctrl droit déconnent complètement

Si je remplace keyEvent->nativeModifiers() par keyEvent->modifiers(), qui renvoie les modifieurs de Qt, alors mon code marche comme attendu.
Ca m'ira, parce qu'il est aisé de faire la conversion en sens inverse. Mais quand même, ça me chagrine ce truc, j'espérais trouver les modifieurs d'origine, tout simplement. En espérant que ça ne me joue pas un tour du même genre pour les Virtual Keys (les autres touches du clavier).

Ou je rate un truc énorme, ou Qt déconne. Mais comme le gestionnaire de clavier de Qt marche quand même bien dans l'ensemble, je dois rater un truc énorme.
Merci bien pour votre aide cheeky

203

Tel que tu le décris et que je comprends la doc, ça semble bien être un bug de Qt. Si tu te sens le courage, regarde dans les sources de Qt. Sinon, prépare un petit test case et reporte-le ^^

PS : rien à voir, mais à la place de & 0x000F, utilise plutôt & (MOD_ALT | MOD_CONTROL | MOD_SHIFT | MOD_WIN), ou carrément & (~MOD_NOREPEAT). Ça t'évite d'avoir des constantes "en dur", c'est plus propre et plus clair.
avatar
— Zeroblog —

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

204

Tu as raison, merci pour ses conseils. smile
Je vais aller voir le code, même si je doute ultra fortement que les gars de Qt se plantent ^^

205

Bon, ben je vais de découverte en découverte.
Voici un screen d'un QKeyEvent qui contient un appui sur Shift : LpTM
on y trouve la valeur de key(), [url=http://doc.qt.io/qt-5/qkeyevent.html#key]censé renvoyer une touche Qt-mapped, complètement délirante
on voit des modifieurs natifs qui valent 513, sur 4 bits c'est pas mal

Donc je comprends mieux mon problème de tout à l'heure avec les modifieurs, sans pour autant expliquer le pourquoi du comment.
Et pour récupérer la touche mappée par Qt, ça a l'air mort. Génial neutral

edit -> tiens, on trouve du 513 ici aussi : http://stackoverflow.com/questions/29332143/how-to-convert-qkeyeventnativemodifiers-to-uint-fsmodifiers-for-winapi-regi


Ok, vive Qt. On regarde ici : https://openclassrooms.com/forum/sujet/qt-petit-probleme-avec-event-gt-key-24382#message-7859665
Je sais pas d'où le mec sort sa structure, mais on retrouve bien le 513 == 512 + 1 == $200 + $1 == NumLock + Shift !!!
Et on voit que Shift et Alt sont bien inversés.
Ah, mon Qt est celui fourni avec un MinGW intégré, ils se mélangerait pas les pinceaux à cause de ça quand même ? Parce que là, on est quand même loin du natif ><

206

Bon, apparemment Qt fait les choses à sa sauce, en lisant manuellement les états un-par-un (ce qui est une belle race condition, au passage) :
http://osxr.org:8080/qt/source/qtbase/src/plugins/platforms/windows/qwindowskeymapper.cpp0); : 0760 bool QWindowsKeyMapper::translateKeyEventInternal(QWindow *window, const MSG &msg, bool /* grab */) 0761 { 0762 const int msgType = msg.message; 0763 0764 const quint32 scancode = (msg.lParam >> 16) & scancodeBitmask; 0765 const quint32 vk_key = msg.wParam; 0766 quint32 nModifiers = 0; 0767 0768 QWindow *receiver = m_keyGrabber ? m_keyGrabber : window; 0769 0770 // Map native modifiers to some bit representation 0771 nModifiers |= (GetKeyState(VK_LSHIFT ) & 0x80 ? ShiftLeft : 0); 0772 nModifiers |= (GetKeyState(VK_RSHIFT ) & 0x80 ? ShiftRight : 0); 0773 nModifiers |= (GetKeyState(VK_LCONTROL) & 0x80 ? ControlLeft : 0); 0774 nModifiers |= (GetKeyState(VK_RCONTROL) & 0x80 ? ControlRight : 0); 0775 nModifiers |= (GetKeyState(VK_LMENU ) & 0x80 ? AltLeft : 0); 0776 nModifiers |= (GetKeyState(VK_RMENU ) & 0x80 ? AltRight : 0); 0777 nModifiers |= (GetKeyState(VK_LWIN ) & 0x80 ? MetaLeft : 0); 0778 nModifiers |= (GetKeyState(VK_RWIN ) & 0x80 ? MetaRight : 0); 0779 // Add Lock keys to the same bits 0780 nModifiers |= (GetKeyState(VK_CAPITAL ) & 0x01 ? CapsLock : 0); 0781 nModifiers |= (GetKeyState(VK_NUMLOCK ) & 0x01 ? NumLock : 0); 0782 nModifiers |= (GetKeyState(VK_SCROLL ) & 0x01 ? ScrollLock : Malgré le nom, les constantes WindowsNativeModifiers ne semblent pas correspondre directement à quoi que ce soit de natif, donc il faudra que tu fasses la correspondance inverse.
Par contre le scan-code et le virtual key code sont directement copiés depuis le message natif, donc tu peux normalement les utiliser directement.
avatar
— Zeroblog —

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

207

Eh ben, merci beaucoup pour ta recherche ! Overdose hier soir, j'ai pas réussi à trouver cette fonction ^^
Et tu sais quoi ? Je ne vois aucun documentation qui se réfère à ces "modifieurs natifs" couic
Et faut encore que je comprenne le souci de ce QKeyEvent::key() qui ne rime à rien ^^

208

Ouais, pour moi ça mérite un bug report sur la doc.
avatar
— Zeroblog —

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

209

Bonne idée. smile

210

Bon, mon dernier problème est le suivant :
Je récupère un QKeyEvent, qui a une méthode key(), censée retourner un code de cette énumération : http://doc.qt.io/qt-5/qt.html#Key-enum
Quand je tape la touche D et lis la valeur, au débogueur, je vois $6B7CDF4F. J'aurais pensé trouver $44, ou Qt::Key_D, comme l'indique la doc. La valeur semble donc complètement aberrante.
Hors, si je crée un QKeySequence sequence(event->key()), sur lequel j'applique la méthode sequence->toString(), je retrouve bien ma chaine "D" !

J'imagine donc que Qt a un secret qui se trouve par là-bas, du côté de la ligne 1290, mais auquel je ne comprends pas grand chose.
Si l'un de vous comprend comment Qt fait en interne, je prends volontiers, merci d'avance !
Aide Charte Contacts Crédits Réalisé avec yAronet 69 ms