Discussion :

[Narann]

Bonjour a tous !

Il y a énormément de documentation sur comment utiliser Qt mais rien sur comment Qt fonctionne sous le capot.

Est-ce que l’un d’entre vous aurait des informations (lien hypertexte, livre, conférence, n’importe quoi) qui pourrait m’indiquer comment Qt fonctionne sous le capot.

Est-ce qu’il calcule tous les pixels de la fenêtre via CPU ? Comment est structurée la hiérarchie de widget a l’écran ? En fait, j’aimerais avoir une vision générale de comment fonctionne le framework, pas de comment on l’utilise.

Merci d’avance !

[dourouc05]

Une grosse partie de Qt concerne les méta-objets, tu peux jeter un coup d'œil à https://louis-du-verdier.developpez.com/qt/fondations/, par exemple.

[LittleWhite]

Bonjour,

On peut aussi tenter l'approche "code source", vu que le code source est disponible. Suffit de se faire une application simple pour tester tel ou tel point de Qt et de plonger dans le code source (à renfort de débogage pas à pas).

[Narann]

Merci pour vos réponses, je viens de lire l’article sur les QObject/moc/méta-objets/etc et il est très intéressant, j’ai beaucoup appris !

Mais il ne répond pas à ma question :

Comment Qt gère l’affichage.

Pour ce qui est du code source, j’ai regardé un peu, mais je n’ai trouvé aucune piste à partir de laquelle creuser. Si l’un d’entre vous aurait la possibilité de m’aiguiller vers des fonctions clefs dans l’affichage de Qt, cela serait un bon début.

[koala01]

Comment Qt gère l’affichage.

Au risque de te paraître (très) brutal, si tu en est encore à poser la question, et surtout sous la forme présente, c'est que la réponse n'aura aucun intérêt pour toi.

Je m'explique:

Qt est un projet qui permet à un développeur débutant de l'utiliser "facilement", mais qui met en oeuvre (en interne) des techniques particulièrement complexes.

Je pourrais donc répondre à ta question en te faisant remarquer que ta question n'est pas assez précise, car la manière de gérer l'affichage dépend du système d'exploitation, et en t'indiquant que Qt fait un usage massif du pimple idiom et même t'expliquer à quoi ressemble cet idiome, mais cela ne servirait sans doute à rien :

Tu comprendrais sans doute la technique, je ne doute pas trop de ce fait. Et puis quoi Tu aurais appris une technique dont tu n'auras de toutes manières aucun besoin avant d'avoir gagné pas mal d'expérience et qui ne facilitera pas ton utilisation de Qt au jour le jour

De toutes manières, Qt est suffisamment bien foutu pour que ces "foutus détails d'implémentations" n'aient aucune espèce d'intérêt dans le cadre de son utilisation "au jour le jour".

Le seul cas dans lequel ils commenceraient éventuellement à avoir un intérêt quelconque serait ... que tu veuilles participer au développement du coeur même du framework, de la partie strictement spécifique à un système d'exploitation donné.

Mais le fait est que, avant de pouvoir envisager une telle participation, il faudra déjà que tu aies acquis non seulement une maîtrise importante du C++ en tant que langage, mais aussi une maîtrise importante de Qt en tant que framework (et, sans doute, une certaine maîtrise du système d'affichage pour le système d'exploitation visé). Et, quand tu auras acquis ces maîtrises, tu te rendras compte que ... tu connais déjà la réponse, et que ta question manquait effectivement de précision...

Du moins, si tu te souvient, à ce moment là, d'avoir initié une discussion sur le sujet "à tes tous débuts".

Il ne faut surtout pas prendre cette remarque pour une attaque personnelle, car elle ne veut sûrement pas en être une. Elle veut juste être un rappel sensé du fait qu'il faut savoir marcher avant de vouloir courir, du fait que C++ est un langage des plus complexes, et du fait que Qt est lui aussi un projet particulièrement complexe.

Or, ces trois faits mis ensembles font que "certaines choses" ne pourront arriver, et avoir une réelle chance d'être comprises que ... quand le moment sera venu, quand les circonstances feront que "tout s'emboîte naturellement".

Je n'émets absolument aucun doute quant au fait qu'il y aura un moment où "tout s’emboîtera" pour toi. Je dis juste qu'il faudra patienter jusqu'à ce que cela t'arrive

Pour ce qui est du code source, j’ai regardé un peu, mais je n’ai trouvé aucune piste à partir de laquelle creuser. Si l’un d’entre vous aurait la possibilité de m’aiguiller vers des fonctions clefs dans l’affichage de Qt, cela serait un bon début.

Si tu tiens à te faire une idée du fonctionnement interne, commence déjà par aller voir du coté des fichiers *.cpp qui se trouvent dans le dossier qtbase/src/corelib/kernel.

Mais je maintiens que ce n'est sans doute pas pour toi "dans l'immédiat".

[Narann]

Bonjour et merci d’avoir pris le temps de répondre.

Vous vous méprenez sur mon expérience et mes compétences.

Ma question est d’ordre culturelle. J’aime bien comprendre comment les choses que j’utilise au quotidien fonctionnent. J’ai énormément utilisé Qt sans trop savoir quel mécanisme/idiome/modèle il utilise pour gérer (au sens « management ») l’affichage des widgets (je sais comment Qt gère les widgets, mais pas comment il les affiche, et je sais que c’est pas via le GPU)

J’aimerais comprendre comment fonctionne (au sens « se gère ») l’affichage des différents frameworks (fltk/wxWidget/Qt). Est-ce qu’il utilise tous une approche similaire, etc.

Merci de m’avoir pointé qtbase/src/corelib/kernel. Je vais creuser un peu la dedans !

Pour spécifier un peu la question :

Je sais ce qui se passe au niveau de la hiérarchie des widgets, de la gestion de la mémoire, j’ai une bonne connaissance en GPU et quelques notions de X. Mais j’ai un gap entre la partie « widget structurés » et comment Qt « dessine les widgets ». Qu’est-ce qu’il cache ? Est-ce qu’il cache, est-ce que c’est l’OS qui cache l’affichage de la fenêtre, etc.

J’ai un « trou » dans mes connaissances entre des concepts avec lesquels je suis a l’aise (management de la mémoire, structure de donne, X, GPU) et l’affichage au niveau de l’OS.

Ducoup, ce que je demandais c’était aussi « qu’est-ce qu’il me manque pour faire la passerelle » entre des connaissances purement informatiques/code/hardware et l’affichage OS.

une certaine maîtrise du système d'affichage pour le système d'exploitation visé

Voila ! Ça c’est déjà un bon élément de réponse. Si tu pouvais m’énumérer quelques concepts à regarder pour élargir un peu ma vision sur le sujet, je suis preneur.

Ce n’est pas les compétences C++ qui me manque (je connais, entre autres pImpl ) c’est plus le nom des concepts que je ne connais pas du tout. pImpl est un bon exemple, si tu sais pas que ça existe, il est difficile de le chercher ou de deviner son nom. Et bien c’est de ce genre d’informations dont j’ai besoins.

Ma question est générale, car elle appelle une réponse générale. Je ne demande pas qu’on m’explique, mais qu’on m’aiguille sur ce que je dois regarder. Après je me débrouille pour creuser.

Merci d'avance !