Discussion :

[d'Oursse]

Je dois porter une lib sous windows, et j'ai un petit probleme pour integrer les messages des fenetres de Windows dans la main loop de ma lib.

Deja, voila comment se fait la gestion des evenements sous Linux:

1) on recupere le descripteur de fichier (fd) de la connection.
2) on appelle une fonction qui fait le monitoring de ce fd (fonction nommee ecore_main_fd_handler_add) a l'aide de select(), et qui est appellee comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
ecore_main_fd_handler_add(fd, ECORE_FD_READ, _ecore_x_fd_handler, data);

_ecore_x_fd_handler est une fonction appellee quand des donnees sont disponibles dans le fd.

Une solution serait la suivante :

1) Je fais une boucle sur les messages de Windows
2) je cree 2 fd et un pipe
3) quand un message est dispo, j'ecris dans un fd
4) ecore_main_fd_handler_add regarde ce qui se passe dans l'autre fd

Ca pourrait marcher, sauf qu'il faut en plus ajouter des threads (et en particulier faire tourner la boucle des messages des fenetres dans un autre thread)

Il me semble que la glib arrive a faire ce que je veux sans ma solution, mais elle utilise un fd particulier (#define G_WIN32_MSG_HANDLE 19981206) et je ne sais pas d'ou il vient

mes questions:

1) Est-ce que ma solution est bonne ?
2) Quelqu'un sait comment glib s'y prend exactement ?
3) Y a-t-il un autre moyen, plus simple pour arriver a integrer les messages des fenetres dans ma main loop ?

merci beacoup

[Médinoc]

Je ne comprends pas trop son système sous Linux, mais sous Windows, pour cumuler les attentes "sur divers trucs" et les messages, on utilise la fonction MsgWaitForMultipleObjects() ou MsgWaitForMultipleObjectsEx() dans une boucle.

Après chaque retour de la fonction, une boucle de PeekMessage() suffit (fais gaffe tout de même pour le WM_QUIT).

[d'Oursse]

je vais essayer d'etre plus clair:

Lorsque mon programme tourne, une boucle d'evenements, nommee b1, est creee, du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
while (1) {
  if (event) {
    /* faire un truc */
  }
}

si une autre boucle, nommee b2, tourne (dans un autre thread), il faut faire en sorte que la boucle b1 soit au courant de tous les evenements envoyes par b2 (vu qu'elle vit dans un autre thread).

Pour cela, sous linux, on cree 2 descripteurs de fichier (fd), nommes fd1 et fd2 et un pont entre ces 2 fd. fd1 est associe a b1 et fd2 est associe a b2. Si un evenement est envoye par b2, on ecrit les donnees necessaires dans fd2. Le pont transmet les donnees a fd1 et la boucle b1 peut savoir si ces donnees sont disponibles, grace a la fonction 'select' (de linux). Pour traiter les donnees, on "associe" a fd1, un callback et les donnees en question grace a une fonction : fd_handler_add qui prend en argument un fd, un callback et la donnee a passer au callback. Ainsi, le code devient:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/* creation du pont */
pipe(&fd1, &fd2); /* la syntaxe n'est pas celle-ci mais c'est pour montrer le code*/

/* on associe a fd1 le cb et la donnee */
fd_handler_add (fd1, mon_callback, ma_donnee);

/* b2, dans un thread a part */
while (1) {
  if (evenement) write (fd2, ma_donnee);
  /* Si on ecrit sur fd2, via le pont, fd1 recoit des donnees */
  /* Le 2eme parametre de write est, en fait, inutilise */
}

/* b1 */
while (1) {
  /* on lit les donnees sur fd1 */
  if (select(fd1) {
    /* cb est la fonction mon_callback ci-dessus, et d est ma_donnee, recuperes par fd_handler_add */
    cb(d);
  }
}

donc, quand on ecrit dans fd2, mon_callback(ma_donnee) est appelee dans b1.

Maintenant, mon probleme vient du fait que b2 est la boucle des messages de windows. Donc, il faut que je fasse passer des donnees de b2 (qui est specifique a windows) a b1 (specifique a linux).

jai fait quelques recherches, et j'ai vu que 'select' sous windows existe, mais pour des sockets.

Donc, ma question, maintenant, serait : est-il possible de creer 2 sockets (nommes aussi fd1 et fd2), un pour b1, l'autre pour b2, de les relier (comme avec pipe ci-dessus), d'ecrire et de lire dans ces sockets, pour que select recupere les donnees de fd1, envoyees par fd2 par le pont ? Ainsi, mes modifications serait mineures, dans la mesure ou b1 n'utilise que select, et rien d'autre specifique a linux (il faudrait aussi que je change le type pour les fd, bien sur).

merci

[d'Oursse]

up