Je ne sais pas si c'est moi, mais je debute en win32 et quelques
concepts ne sont pas tres clairs voire confus.
Mes questions sont surtout liees a ce que je connaissais deja, a savoir
java et c/gtk ou les objets ont un role assez bien defini (canvas,
composants,...) et les evenements geres a raison d'un listener par objet
et par type d'evenement.
Je precise que j'ai regarde plusieurs tutoriels et qu'ils ne repondent
pas vraiment a ces questions.
1/ j'ai bien compris: tous les objets graphiques sont des fenetres
(HDWND)? Il n'y a aucune distinction entre les fenetres pour le dessin
et les fenetres pour le texte, ou servant de conteneur?
2/ je parlais des listener par objet et par evenement plus haut. Est-ce
qu'il est possible de faire quelque chose de ce style en win32?
D'apres msdn, et les exemples de code que j'ai vus, on ne peut avoir
qu'une winproc par classe de fenetre. Peut-on avoir plusieurs classes
dans la meme appli? une fenetre de classe c1 peut-il etre 'child' d'une
fenetre de classe c2?
3/ comment je fais des compositions? par exemple, avoir une zone pour
les boutons a gauche et une zone de dessin a droite. Je peux ajouter une
HDWND pour les boutons et une autre pour les dessins? Comment ca se
passe au niveau de la winproc?
Exemple, j'ai l'arrangement de composition suivant (en supposant que ce
soit possible):
HWND racine
|- HWND zoneBoutons
| |- bouton 1
| |- bouton 2
|- HWND zoneDessin
Si je clique sur bouton2, c'est lui qui va etre donne par le LPARAM de
winproc, ou c'est zoneBoutons?
Desole, si c'est vraiment trop trivial.
En tous cas, merci d'avance.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Cyrille Szymanski
Ploc wrote in news:43fb5158$0$4753$:
Je precise que j'ai regarde plusieurs tutoriels et qu'ils ne repondent pas vraiment a ces questions.
Mets la main sur le Petzold (cf FAQ de ce groupe). Ce livre répondra à toutes tes questions.
En attendant :
1/ j'ai bien compris: tous les objets graphiques sont des fenetres (HDWND)? Il n'y a aucune distinction entre les fenetres pour le dessin et les fenetres pour le texte, ou servant de conteneur?
En gros c'est cela. Une fenêtre est juste une zone rectangulaire qui reçoit des messages au moyen de sa WndProc et qui est identifiée par son handle de fenêtre HWND.
une fenetre de classe c1 peut-il etre 'child' d'une fenetre de classe c2?
Je ne sais pas ce que tu entends par être 'child', mais d'une part CreateWindow prend en argument un HWND parent, d'autre part le subclassing te permet de faire une sorte d'héritage entre les composants.
3/ comment je fais des compositions? par exemple, avoir une zone pour les boutons a gauche et une zone de dessin a droite. Je peux ajouter une HDWND pour les boutons et une autre pour les dessins?
Tu peux faire cela. ZoneBoutons aura alors sa propre WndProc différente de celle de ta fenêtre principale. Il te faudra faire un SendMessage(GetParent(hwnd), message, wParam, lParam); pour passer au parent les messages que tu ne veux pas traiter.
Si je clique sur bouton2, c'est lui qui va etre donne par le LPARAM de winproc, ou c'est zoneBoutons?
Lors d'un clic sur un bouton, il envoie le message WM_COMMAND à son parent (donc zoneBoutons). LOWORD (wParam) sera égal au window ID et lParam sera égal au HWND du bouton. Il est bien sûr plus pratique de travailler avec les window ID pour identifier le bouton qui vient d'être cliqué.
-- Cyrille Szymanski
Ploc <ploc@clop.invalid> wrote in
news:43fb5158$0$4753$636a55ce@news.free.fr:
Je precise que j'ai regarde plusieurs tutoriels et qu'ils ne repondent
pas vraiment a ces questions.
Mets la main sur le Petzold (cf FAQ de ce groupe). Ce livre répondra à
toutes tes questions.
En attendant :
1/ j'ai bien compris: tous les objets graphiques sont des fenetres
(HDWND)? Il n'y a aucune distinction entre les fenetres pour le dessin
et les fenetres pour le texte, ou servant de conteneur?
En gros c'est cela. Une fenêtre est juste une zone rectangulaire qui
reçoit des messages au moyen de sa WndProc et qui est identifiée par son
handle de fenêtre HWND.
une fenetre de classe c1 peut-il etre 'child' d'une fenetre de classe
c2?
Je ne sais pas ce que tu entends par être 'child', mais d'une part
CreateWindow prend en argument un HWND parent, d'autre part le
subclassing te permet de faire une sorte d'héritage entre les
composants.
3/ comment je fais des compositions? par exemple, avoir une zone pour
les boutons a gauche et une zone de dessin a droite. Je peux ajouter
une HDWND pour les boutons et une autre pour les dessins?
Tu peux faire cela. ZoneBoutons aura alors sa propre WndProc différente
de celle de ta fenêtre principale. Il te faudra faire un
SendMessage(GetParent(hwnd), message, wParam, lParam);
pour passer au parent les messages que tu ne veux pas traiter.
Si je clique sur bouton2, c'est lui qui va etre donne par le LPARAM de
winproc, ou c'est zoneBoutons?
Lors d'un clic sur un bouton, il envoie le message WM_COMMAND à son
parent (donc zoneBoutons). LOWORD (wParam) sera égal au window ID et
lParam sera égal au HWND du bouton. Il est bien sûr plus pratique de
travailler avec les window ID pour identifier le bouton qui vient d'être
cliqué.
Je precise que j'ai regarde plusieurs tutoriels et qu'ils ne repondent pas vraiment a ces questions.
Mets la main sur le Petzold (cf FAQ de ce groupe). Ce livre répondra à toutes tes questions.
En attendant :
1/ j'ai bien compris: tous les objets graphiques sont des fenetres (HDWND)? Il n'y a aucune distinction entre les fenetres pour le dessin et les fenetres pour le texte, ou servant de conteneur?
En gros c'est cela. Une fenêtre est juste une zone rectangulaire qui reçoit des messages au moyen de sa WndProc et qui est identifiée par son handle de fenêtre HWND.
une fenetre de classe c1 peut-il etre 'child' d'une fenetre de classe c2?
Je ne sais pas ce que tu entends par être 'child', mais d'une part CreateWindow prend en argument un HWND parent, d'autre part le subclassing te permet de faire une sorte d'héritage entre les composants.
3/ comment je fais des compositions? par exemple, avoir une zone pour les boutons a gauche et une zone de dessin a droite. Je peux ajouter une HDWND pour les boutons et une autre pour les dessins?
Tu peux faire cela. ZoneBoutons aura alors sa propre WndProc différente de celle de ta fenêtre principale. Il te faudra faire un SendMessage(GetParent(hwnd), message, wParam, lParam); pour passer au parent les messages que tu ne veux pas traiter.
Si je clique sur bouton2, c'est lui qui va etre donne par le LPARAM de winproc, ou c'est zoneBoutons?
Lors d'un clic sur un bouton, il envoie le message WM_COMMAND à son parent (donc zoneBoutons). LOWORD (wParam) sera égal au window ID et lParam sera égal au HWND du bouton. Il est bien sûr plus pratique de travailler avec les window ID pour identifier le bouton qui vient d'être cliqué.
-- Cyrille Szymanski
Arnaud Debaene
Ploc wrote:
Bonjour,
Je ne sais pas si c'est moi, mais je debute en win32 et quelques concepts ne sont pas tres clairs voire confus. Mes questions sont surtout liees a ce que je connaissais deja, a savoir java et c/gtk ou les objets ont un role assez bien defini (canvas, composants,...) et les evenements geres a raison d'un listener par objet et par type d'evenement.
Tout d'abord, il faut te rappeler que l'AP Win32 est en C, et pas dans un langage orienté objet. Même s'il y a des concepts objets dans le modèle des fenêtres Win32, cette orientation technique implique forcément des limitations.
Il existe des tas de librairies objet qui wrappent l'API Win32 dnas un modèle un peu plus cohérent. Citons entre autres les MFC (très mauvaises d'un point de vue objet), le couple ATL/WTL ou bien Win32Gui. Il y en a des tas d'autres.
Je precise que j'ai regarde plusieurs tutoriels et qu'ils ne repondent pas vraiment a ces questions.
1/ j'ai bien compris: tous les objets graphiques sont des fenetres (HDWND)? Il n'y a aucune distinction entre les fenetres pour le dessin et les fenetres pour le texte, ou servant de conteneur?
Une fenêtre (identifiée par son HWND) est une zone rectangulaire à l'écran. Ensuite, ce qui va différencier les différentes fenêtres, c'est leur style (qui impose certains éléments graphiques comme une bordure, une barre de titre, etc...) et leur classe (càd leur WndProc, donc leur comportement).
2/ je parlais des listener par objet et par evenement plus haut. Est-ce qu'il est possible de faire quelque chose de ce style en win32? D'apres msdn, et les exemples de code que j'ai vus, on ne peut avoir qu'une winproc par classe de fenetre. Peut-on avoir plusieurs classes dans la meme appli? une fenetre de classe c1 peut-il etre 'child' d'une fenetre de classe c2?
Il y a généralement une pompe à message par fenêtre "top level" qui dispatche les messages vers toutes ses fenêtres filles. Effectivement, ensuite chaque fenêter à sa WndProc qui détermine son comportement, donc sa classe. Il est possible de modifier le comportement d'une fenêtre en la "sous-classant" ou la "super-classant" : je te laisse regarder dans MSDN pour les détails. Grosso-Mdo, il s'agit de changer la WndProc d'une instance de fenêter (en fournissant un pointeur vers une autre XWndProc), ou bien de chainer plusieurs WndProc. L'effet final est assez proche de ce qu'on peut attndre de la dérivation et de la surcharge dans le monde objet, mais avec une approche différente.
3/ comment je fais des compositions? par exemple, avoir une zone pour les boutons a gauche et une zone de dessin a droite. Je peux ajouter une HDWND pour les boutons et une autre pour les dessins? Comment ca se passe au niveau de la winproc?
Tu créé des fenêters filles dans une fenêtre "container" parent. La WndProc par défaut se charge de faire le dispatching des messages arrivant à la fenêtre parent aux fenêtres enfants.
Exemple, j'ai l'arrangement de composition suivant (en supposant que ce soit possible): HWND racine |- HWND zoneBoutons | |- bouton 1 | |- bouton 2 |- HWND zoneDessin
Si je clique sur bouton2, c'est lui qui va etre donne par le LPARAM de winproc, ou c'est zoneBoutons?
Un controle (cas particulier de fenêtre) envoie un message WM_COMMAND à son parent (zoneBoutons) pour le notifier d'événements. C'est la fenête parent (racine ou bien zoneBoutons - en pratique le plus souvent racine parce que zoneBoutons n'est là que comme élément graphique et n'a pas de logique propre) qui gère ce message dans sa WndProc et réagit en conséquence.
Arnaud MVP - VC
Ploc wrote:
Bonjour,
Je ne sais pas si c'est moi, mais je debute en win32 et quelques
concepts ne sont pas tres clairs voire confus.
Mes questions sont surtout liees a ce que je connaissais deja, a
savoir java et c/gtk ou les objets ont un role assez bien defini
(canvas, composants,...) et les evenements geres a raison d'un
listener par objet et par type d'evenement.
Tout d'abord, il faut te rappeler que l'AP Win32 est en C, et pas dans un
langage orienté objet. Même s'il y a des concepts objets dans le modèle des
fenêtres Win32, cette orientation technique implique forcément des
limitations.
Il existe des tas de librairies objet qui wrappent l'API Win32 dnas un
modèle un peu plus cohérent. Citons entre autres les MFC (très mauvaises
d'un point de vue objet), le couple ATL/WTL ou bien Win32Gui. Il y en a des
tas d'autres.
Je precise que j'ai regarde plusieurs tutoriels et qu'ils ne repondent
pas vraiment a ces questions.
1/ j'ai bien compris: tous les objets graphiques sont des fenetres
(HDWND)? Il n'y a aucune distinction entre les fenetres pour le dessin
et les fenetres pour le texte, ou servant de conteneur?
Une fenêtre (identifiée par son HWND) est une zone rectangulaire à l'écran.
Ensuite, ce qui va différencier les différentes fenêtres, c'est leur style
(qui impose certains éléments graphiques comme une bordure, une barre de
titre, etc...) et leur classe (càd leur WndProc, donc leur comportement).
2/ je parlais des listener par objet et par evenement plus haut.
Est-ce qu'il est possible de faire quelque chose de ce style en win32?
D'apres msdn, et les exemples de code que j'ai vus, on ne peut avoir
qu'une winproc par classe de fenetre. Peut-on avoir plusieurs classes
dans la meme appli? une fenetre de classe c1 peut-il etre 'child'
d'une fenetre de classe c2?
Il y a généralement une pompe à message par fenêtre "top level" qui
dispatche les messages vers toutes ses fenêtres filles. Effectivement,
ensuite chaque fenêter à sa WndProc qui détermine son comportement, donc sa
classe. Il est possible de modifier le comportement d'une fenêtre en la
"sous-classant" ou la "super-classant" : je te laisse regarder dans MSDN
pour les détails. Grosso-Mdo, il s'agit de changer la WndProc d'une instance
de fenêter (en fournissant un pointeur vers une autre XWndProc), ou bien de
chainer plusieurs WndProc. L'effet final est assez proche de ce qu'on peut
attndre de la dérivation et de la surcharge dans le monde objet, mais avec
une approche différente.
3/ comment je fais des compositions? par exemple, avoir une zone pour
les boutons a gauche et une zone de dessin a droite. Je peux ajouter
une HDWND pour les boutons et une autre pour les dessins? Comment ca
se passe au niveau de la winproc?
Tu créé des fenêters filles dans une fenêtre "container" parent. La WndProc
par défaut se charge de faire le dispatching des messages arrivant à la
fenêtre parent aux fenêtres enfants.
Exemple, j'ai l'arrangement de composition suivant (en supposant que
ce soit possible):
HWND racine
|- HWND zoneBoutons
| |- bouton 1
| |- bouton 2
|- HWND zoneDessin
Si je clique sur bouton2, c'est lui qui va etre donne par le LPARAM de
winproc, ou c'est zoneBoutons?
Un controle (cas particulier de fenêtre) envoie un message WM_COMMAND à son
parent (zoneBoutons) pour le notifier d'événements.
C'est la fenête parent (racine ou bien zoneBoutons - en pratique le plus
souvent racine parce que zoneBoutons n'est là que comme élément graphique et
n'a pas de logique propre) qui gère ce message dans sa WndProc et réagit en
conséquence.
Je ne sais pas si c'est moi, mais je debute en win32 et quelques concepts ne sont pas tres clairs voire confus. Mes questions sont surtout liees a ce que je connaissais deja, a savoir java et c/gtk ou les objets ont un role assez bien defini (canvas, composants,...) et les evenements geres a raison d'un listener par objet et par type d'evenement.
Tout d'abord, il faut te rappeler que l'AP Win32 est en C, et pas dans un langage orienté objet. Même s'il y a des concepts objets dans le modèle des fenêtres Win32, cette orientation technique implique forcément des limitations.
Il existe des tas de librairies objet qui wrappent l'API Win32 dnas un modèle un peu plus cohérent. Citons entre autres les MFC (très mauvaises d'un point de vue objet), le couple ATL/WTL ou bien Win32Gui. Il y en a des tas d'autres.
Je precise que j'ai regarde plusieurs tutoriels et qu'ils ne repondent pas vraiment a ces questions.
1/ j'ai bien compris: tous les objets graphiques sont des fenetres (HDWND)? Il n'y a aucune distinction entre les fenetres pour le dessin et les fenetres pour le texte, ou servant de conteneur?
Une fenêtre (identifiée par son HWND) est une zone rectangulaire à l'écran. Ensuite, ce qui va différencier les différentes fenêtres, c'est leur style (qui impose certains éléments graphiques comme une bordure, une barre de titre, etc...) et leur classe (càd leur WndProc, donc leur comportement).
2/ je parlais des listener par objet et par evenement plus haut. Est-ce qu'il est possible de faire quelque chose de ce style en win32? D'apres msdn, et les exemples de code que j'ai vus, on ne peut avoir qu'une winproc par classe de fenetre. Peut-on avoir plusieurs classes dans la meme appli? une fenetre de classe c1 peut-il etre 'child' d'une fenetre de classe c2?
Il y a généralement une pompe à message par fenêtre "top level" qui dispatche les messages vers toutes ses fenêtres filles. Effectivement, ensuite chaque fenêter à sa WndProc qui détermine son comportement, donc sa classe. Il est possible de modifier le comportement d'une fenêtre en la "sous-classant" ou la "super-classant" : je te laisse regarder dans MSDN pour les détails. Grosso-Mdo, il s'agit de changer la WndProc d'une instance de fenêter (en fournissant un pointeur vers une autre XWndProc), ou bien de chainer plusieurs WndProc. L'effet final est assez proche de ce qu'on peut attndre de la dérivation et de la surcharge dans le monde objet, mais avec une approche différente.
3/ comment je fais des compositions? par exemple, avoir une zone pour les boutons a gauche et une zone de dessin a droite. Je peux ajouter une HDWND pour les boutons et une autre pour les dessins? Comment ca se passe au niveau de la winproc?
Tu créé des fenêters filles dans une fenêtre "container" parent. La WndProc par défaut se charge de faire le dispatching des messages arrivant à la fenêtre parent aux fenêtres enfants.
Exemple, j'ai l'arrangement de composition suivant (en supposant que ce soit possible): HWND racine |- HWND zoneBoutons | |- bouton 1 | |- bouton 2 |- HWND zoneDessin
Si je clique sur bouton2, c'est lui qui va etre donne par le LPARAM de winproc, ou c'est zoneBoutons?
Un controle (cas particulier de fenêtre) envoie un message WM_COMMAND à son parent (zoneBoutons) pour le notifier d'événements. C'est la fenête parent (racine ou bien zoneBoutons - en pratique le plus souvent racine parce que zoneBoutons n'est là que comme élément graphique et n'a pas de logique propre) qui gère ce message dans sa WndProc et réagit en conséquence.
Arnaud MVP - VC
Ploc
Arnaud Debaene wrote:
Ploc wrote:
Bonjour,
Je ne sais pas si c'est moi, mais je debute en win32 et quelques concepts ne sont pas tres clairs voire confus. Mes questions sont surtout liees a ce que je connaissais deja, a savoir java et c/gtk ou les objets ont un role assez bien defini (canvas, composants,...) et les evenements geres a raison d'un listener par objet et par type d'evenement.
Tout d'abord, il faut te rappeler que l'AP Win32 est en C, et pas dans un langage orienté objet. Même s'il y a des concepts objets dans le modèle des fenêtres Win32, cette orientation technique implique forcément des limitations.
Gtk est egalement en C, meme si ils ont fait un couche objet qui fait faire des fois pas tres jolies. Il y'a evidemment des concepts avec lesquelles je dois me familiariser. Pour l'instant, la chose que je trouve vraiment regrettable, ce sont les fonctions fourre-tout comme SetWindowLong, mais l'API est comme ca...
Il existe des tas de librairies objet qui wrappent l'API Win32 dnas un modèle un peu plus cohérent. Citons entre autres les MFC (très mauvaises d'un point de vue objet), le couple ATL/WTL ou bien Win32Gui. Il y en a des tas d'autres.
Je precise que j'ai regarde plusieurs tutoriels et qu'ils ne repondent pas vraiment a ces questions.
1/ j'ai bien compris: tous les objets graphiques sont des fenetres (HDWND)? Il n'y a aucune distinction entre les fenetres pour le dessin et les fenetres pour le texte, ou servant de conteneur?
Une fenêtre (identifiée par son HWND) est une zone rectangulaire à l'écran. Ensuite, ce qui va différencier les différentes fenêtres, c'est leur style (qui impose certains éléments graphiques comme une bordure, une barre de titre, etc...) et leur classe (càd leur WndProc, donc leur comportement).
ok
2/ je parlais des listener par objet et par evenement plus haut. Est-ce qu'il est possible de faire quelque chose de ce style en win32? D'apres msdn, et les exemples de code que j'ai vus, on ne peut avoir qu'une winproc par classe de fenetre. Peut-on avoir plusieurs classes dans la meme appli? une fenetre de classe c1 peut-il etre 'child' d'une fenetre de classe c2?
Il y a généralement une pompe à message par fenêtre "top level" qui dispatche les messages vers toutes ses fenêtres filles. Effectivement, ensuite chaque fenêter à sa WndProc qui détermine son comportement, donc sa classe. Il est possible de modifier le comportement d'une fenêtre en la "sous-classant" ou la "super-classant" : je te laisse regarder dans MSDN pour les détails. Grosso-Mdo, il s'agit de changer la WndProc d'une instance de fenêter (en fournissant un pointeur vers une autre XWndProc), ou bien de chainer plusieurs WndProc. L'effet final est assez proche de ce qu'on peut attndre de la dérivation et de la surcharge dans le monde objet, mais avec une approche différente.
Oui, c'est aussi ce que disait Cyril Szymanski. C'est pourtant indique dans msdn (window procedures overviews), mais "subclassing a window" ne me semblait pas convenir. Deformation objet surement.
3/ comment je fais des compositions? par exemple, avoir une zone pour les boutons a gauche et une zone de dessin a droite. Je peux ajouter une HDWND pour les boutons et une autre pour les dessins? Comment ca se passe au niveau de la winproc?
Tu créé des fenêters filles dans une fenêtre "container" parent. La WndProc par défaut se charge de faire le dispatching des messages arrivant à la fenêtre parent aux fenêtres enfants.
Exemple, j'ai l'arrangement de composition suivant (en supposant que ce soit possible): HWND racine |- HWND zoneBoutons | |- bouton 1 | |- bouton 2 |- HWND zoneDessin
Si je clique sur bouton2, c'est lui qui va etre donne par le LPARAM de winproc, ou c'est zoneBoutons?
Un controle (cas particulier de fenêtre) envoie un message WM_COMMAND à son parent (zoneBoutons) pour le notifier d'événements. C'est la fenête parent (racine ou bien zoneBoutons - en pratique le plus souvent racine parce que zoneBoutons n'est là que comme élément graphique et n'a pas de logique propre) qui gère ce message dans sa WndProc et réagit en conséquence.
Ok, je vais essayer de me debrouiller avec ca. Merci a tous les 2.
Arnaud Debaene wrote:
Ploc wrote:
Bonjour,
Je ne sais pas si c'est moi, mais je debute en win32 et quelques
concepts ne sont pas tres clairs voire confus.
Mes questions sont surtout liees a ce que je connaissais deja, a
savoir java et c/gtk ou les objets ont un role assez bien defini
(canvas, composants,...) et les evenements geres a raison d'un
listener par objet et par type d'evenement.
Tout d'abord, il faut te rappeler que l'AP Win32 est en C, et pas dans un
langage orienté objet. Même s'il y a des concepts objets dans le modèle des
fenêtres Win32, cette orientation technique implique forcément des
limitations.
Gtk est egalement en C, meme si ils ont fait un couche objet qui fait
faire des fois pas tres jolies.
Il y'a evidemment des concepts avec lesquelles je dois me familiariser.
Pour l'instant, la chose que je trouve vraiment regrettable, ce sont les
fonctions fourre-tout comme SetWindowLong, mais l'API est comme ca...
Il existe des tas de librairies objet qui wrappent l'API Win32 dnas un
modèle un peu plus cohérent. Citons entre autres les MFC (très mauvaises
d'un point de vue objet), le couple ATL/WTL ou bien Win32Gui. Il y en a des
tas d'autres.
Je precise que j'ai regarde plusieurs tutoriels et qu'ils ne repondent
pas vraiment a ces questions.
1/ j'ai bien compris: tous les objets graphiques sont des fenetres
(HDWND)? Il n'y a aucune distinction entre les fenetres pour le dessin
et les fenetres pour le texte, ou servant de conteneur?
Une fenêtre (identifiée par son HWND) est une zone rectangulaire à l'écran.
Ensuite, ce qui va différencier les différentes fenêtres, c'est leur style
(qui impose certains éléments graphiques comme une bordure, une barre de
titre, etc...) et leur classe (càd leur WndProc, donc leur comportement).
ok
2/ je parlais des listener par objet et par evenement plus haut.
Est-ce qu'il est possible de faire quelque chose de ce style en win32?
D'apres msdn, et les exemples de code que j'ai vus, on ne peut avoir
qu'une winproc par classe de fenetre. Peut-on avoir plusieurs classes
dans la meme appli? une fenetre de classe c1 peut-il etre 'child'
d'une fenetre de classe c2?
Il y a généralement une pompe à message par fenêtre "top level" qui
dispatche les messages vers toutes ses fenêtres filles. Effectivement,
ensuite chaque fenêter à sa WndProc qui détermine son comportement, donc sa
classe. Il est possible de modifier le comportement d'une fenêtre en la
"sous-classant" ou la "super-classant" : je te laisse regarder dans MSDN
pour les détails. Grosso-Mdo, il s'agit de changer la WndProc d'une instance
de fenêter (en fournissant un pointeur vers une autre XWndProc), ou bien de
chainer plusieurs WndProc. L'effet final est assez proche de ce qu'on peut
attndre de la dérivation et de la surcharge dans le monde objet, mais avec
une approche différente.
Oui, c'est aussi ce que disait Cyril Szymanski.
C'est pourtant indique dans msdn (window procedures overviews), mais
"subclassing a window" ne me semblait pas convenir. Deformation objet
surement.
3/ comment je fais des compositions? par exemple, avoir une zone pour
les boutons a gauche et une zone de dessin a droite. Je peux ajouter
une HDWND pour les boutons et une autre pour les dessins? Comment ca
se passe au niveau de la winproc?
Tu créé des fenêters filles dans une fenêtre "container" parent. La WndProc
par défaut se charge de faire le dispatching des messages arrivant à la
fenêtre parent aux fenêtres enfants.
Exemple, j'ai l'arrangement de composition suivant (en supposant que
ce soit possible):
HWND racine
|- HWND zoneBoutons
| |- bouton 1
| |- bouton 2
|- HWND zoneDessin
Si je clique sur bouton2, c'est lui qui va etre donne par le LPARAM de
winproc, ou c'est zoneBoutons?
Un controle (cas particulier de fenêtre) envoie un message WM_COMMAND à son
parent (zoneBoutons) pour le notifier d'événements.
C'est la fenête parent (racine ou bien zoneBoutons - en pratique le plus
souvent racine parce que zoneBoutons n'est là que comme élément graphique et
n'a pas de logique propre) qui gère ce message dans sa WndProc et réagit en
conséquence.
Ok, je vais essayer de me debrouiller avec ca.
Merci a tous les 2.
Je ne sais pas si c'est moi, mais je debute en win32 et quelques concepts ne sont pas tres clairs voire confus. Mes questions sont surtout liees a ce que je connaissais deja, a savoir java et c/gtk ou les objets ont un role assez bien defini (canvas, composants,...) et les evenements geres a raison d'un listener par objet et par type d'evenement.
Tout d'abord, il faut te rappeler que l'AP Win32 est en C, et pas dans un langage orienté objet. Même s'il y a des concepts objets dans le modèle des fenêtres Win32, cette orientation technique implique forcément des limitations.
Gtk est egalement en C, meme si ils ont fait un couche objet qui fait faire des fois pas tres jolies. Il y'a evidemment des concepts avec lesquelles je dois me familiariser. Pour l'instant, la chose que je trouve vraiment regrettable, ce sont les fonctions fourre-tout comme SetWindowLong, mais l'API est comme ca...
Il existe des tas de librairies objet qui wrappent l'API Win32 dnas un modèle un peu plus cohérent. Citons entre autres les MFC (très mauvaises d'un point de vue objet), le couple ATL/WTL ou bien Win32Gui. Il y en a des tas d'autres.
Je precise que j'ai regarde plusieurs tutoriels et qu'ils ne repondent pas vraiment a ces questions.
1/ j'ai bien compris: tous les objets graphiques sont des fenetres (HDWND)? Il n'y a aucune distinction entre les fenetres pour le dessin et les fenetres pour le texte, ou servant de conteneur?
Une fenêtre (identifiée par son HWND) est une zone rectangulaire à l'écran. Ensuite, ce qui va différencier les différentes fenêtres, c'est leur style (qui impose certains éléments graphiques comme une bordure, une barre de titre, etc...) et leur classe (càd leur WndProc, donc leur comportement).
ok
2/ je parlais des listener par objet et par evenement plus haut. Est-ce qu'il est possible de faire quelque chose de ce style en win32? D'apres msdn, et les exemples de code que j'ai vus, on ne peut avoir qu'une winproc par classe de fenetre. Peut-on avoir plusieurs classes dans la meme appli? une fenetre de classe c1 peut-il etre 'child' d'une fenetre de classe c2?
Il y a généralement une pompe à message par fenêtre "top level" qui dispatche les messages vers toutes ses fenêtres filles. Effectivement, ensuite chaque fenêter à sa WndProc qui détermine son comportement, donc sa classe. Il est possible de modifier le comportement d'une fenêtre en la "sous-classant" ou la "super-classant" : je te laisse regarder dans MSDN pour les détails. Grosso-Mdo, il s'agit de changer la WndProc d'une instance de fenêter (en fournissant un pointeur vers une autre XWndProc), ou bien de chainer plusieurs WndProc. L'effet final est assez proche de ce qu'on peut attndre de la dérivation et de la surcharge dans le monde objet, mais avec une approche différente.
Oui, c'est aussi ce que disait Cyril Szymanski. C'est pourtant indique dans msdn (window procedures overviews), mais "subclassing a window" ne me semblait pas convenir. Deformation objet surement.
3/ comment je fais des compositions? par exemple, avoir une zone pour les boutons a gauche et une zone de dessin a droite. Je peux ajouter une HDWND pour les boutons et une autre pour les dessins? Comment ca se passe au niveau de la winproc?
Tu créé des fenêters filles dans une fenêtre "container" parent. La WndProc par défaut se charge de faire le dispatching des messages arrivant à la fenêtre parent aux fenêtres enfants.
Exemple, j'ai l'arrangement de composition suivant (en supposant que ce soit possible): HWND racine |- HWND zoneBoutons | |- bouton 1 | |- bouton 2 |- HWND zoneDessin
Si je clique sur bouton2, c'est lui qui va etre donne par le LPARAM de winproc, ou c'est zoneBoutons?
Un controle (cas particulier de fenêtre) envoie un message WM_COMMAND à son parent (zoneBoutons) pour le notifier d'événements. C'est la fenête parent (racine ou bien zoneBoutons - en pratique le plus souvent racine parce que zoneBoutons n'est là que comme élément graphique et n'a pas de logique propre) qui gère ce message dans sa WndProc et réagit en conséquence.
Ok, je vais essayer de me debrouiller avec ca. Merci a tous les 2.
