Discussion :

[kipgon]

Salut à tous,

j'ai déjà posé une question sur ce sujet il y a un moment mais la solution pour laquelle j'avais opté ne me convient plus à vrai dire !

Je poste cette discussion dans le forum c++ car je pense que cela concerne d'avantage la partie c++ que la partie Qt.

Cela ne doit pas être bien compliqué mais je ne comprend pas vraiment ce qu'il se passe !

Je vous explique

Mon but est d'ouvrir une fenêtre avec une image généré par mon programme à l’intérieur lorsque l'on appuie sur un bouton. Voici les étape que je réalise :

Quand je clique sur le bouton :

étape 1 : je génère une image (png).
étape 2 : j'ouvre cette image dans un QPixmap de la fenêtre à ouvrir.

Le problème c'est que le fichier ne se crée pas assez vite et que la fenêtre cherche à s'ouvrir avant ce qui abouti à une fenêtre vide .

La solution que j'avais choisi était d’effectuer un "gros" sleep (Sleep(500)) mais bon se n'est pas très "propre" je suis sur qu'il doit exister une solution qui permette d'attendre juste le temps qu'il faut !

Pour info j'essaie de faire :

Code :

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

1
2
3
4
5
6
7
 
QFile img("image.png");
 
while (img.exists()==false)
{
     Sleep(1);
}

mais cela ne fonctionne pas ! Cela ne fonctionne que si je mets

Code :

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

1
2
3
4
5
6
7
 
QFile img("image.png");
 
while (img.exists()==false)
{
     Sleep(500);
}

Quelqu'un aurait une idée ?

[ternel]

Sleep est bien en millisecondes?

dans ce cas, dormir pendant une demie seconde est largement préférable.

[Neckara]

Bonjour,

A la fin de la création de ton fichier, ne peux-tu pas émettre un signal et le connecter à un slot qui ouvrira ta fenêtre ?

[kipgon]

Pour Sleep j'ai lu aussi que cela était en milliseconde mais dans mon cas cela semble être beaucoup plus long qu'une demi seconde ! Ne me demandez pas pourquoi !

Et pour le signal j'ai essayé, en terminant ma fonction par

Code :

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

emit signal()

et en créant une autre fonction qui lance la fenêtre mais cela se passe exactement de la même manière !

[ternel]

Attends, tu sais qu'écrire une image peut être long quand elle est grosse.

Tu as vérifié si le problème persiste en écrivant une image d'un seul pixel?

[kipgon]

Oui je sais que ça peut être long, ce que je voudrais c'est faire comprendre à mon programme qu'il doit attendre "le temps qu'il faut" (pas plus, pas moins donc un temps variable en fonction de l'image générée) avant de continuer

[haraelendil]

Oui bah la version en émettant un signal devrait marche, mais on ne peut pas savoir pourquoi ça ne marche pas si on a pas un peu plus de code...

[imperio]

Je pense que ça vient plus d'un manque de connaissance de Qt de ta part qu'un véritable problème. Il y a plusieurs solutions :

- tout mettre dans la boucle principale, en gros tu crées ton image et quand c'est bon tu fais continuer ton programme (tu peux mettre sa création dans le constructeur de ta fenêtre pour être plus sûr si tu veux).
- lancer un QThread qui émettra un signal auquel ta fenêtre principale sera connectée (avec la méthode QObject::connect). Regarde les exemples sur le net.

La seconde solution est plus Qt-like.

[kipgon]

C'est même certain, cela vient d'un manque de connaissances de ma part . Je suis un peu "nouveau" en c++ + Qt.

Merci pour ce message, c'est très intéressant je vais me documenter sur les QThread, il est vrai que je ne sais pas bien ce que c'est ! Il me semble que cela permet au programme de faire "plusieurs choses à la fois".

Cela dit la première méthode est celle que j'essayais d'implémenter mais je n'ai pas réussi .

Qu’entendez vous par "mettre sa construction" dans le constructeur de la fenêtre ?

[imperio]

Merci pour ce message, c'est très intéressant je vais me documenter sur les QThread, il est vrai que je ne sais pas bien ce que c'est ! Il me semble que cela permet au programme de faire "plusieurs choses à la fois".

Les QThreads sont une réimplementation des threads qui sont des processus dits "légers". En gros tu peux exécuter deux choses en même temps grâce à eux. Il est montré dans la doc comment les implémenter, je te recommande donc fortement d'aller y faire un tour. Et n'hésite pas à aller te renseigner sur les threads sur internet.

Cela dit la première méthode est celle que j'essayais d'implémenter mais je n'ai pas réussi .

Qu’entendez vous par "mettre sa construction" dans le constructeur de la fenêtre ?

Tout simplement ceci :

- soit createPicture la fonction / classe / méthode qui crée le .png.
- soit Window le nom de ta classe qui crée ta fenêtre.

Petit exemple :

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
23
 
// code de ta classe Window
 
class Window : public QWidget
{
public:
  Windows() : QWidget(0)
  {
    //nous sommes donc ici dans le constructeur de la classe window
    // on appelle la fonction / méthode / classe chargée de créer l'image ici
    createPicture();
    //quand l'image est créée, tu peux la mettre dans ta fenêtre
  }
};
 
int main(int ac, char **av)
{
  QApplication app(ac, av);
  Window   w;
 
  w.show();
  return app.exec();
}

Un petit rappel sur les bases du C++ te ferait du bien je pense.

[kipgon]

Aaaaaaah je viens de comprendre !

J'essaie ça et je vous dit ce qu'il en est ! Merci beaucoup !

[kipgon]

En fait par cette méthode le problème est le même

Mon image est généré par un programme extérieur si cela peut aider ! Programme nommé gnuplot !

J'utilise la commande

Code :

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

WinExec("gnuplot.exe fonction.gnu", SW_HIDE);

Qui me permet d'exécuter un fichier de commande contenant les informations sur ma fonction.

Je dois ensuite attendre que mon image soit généré par ce programme pour pouvoir continuer !

[imperio]

Il faudra que tu te débrouilles pour récupérer le HANDLE du processus pour l'envoyer dans cette fonction. Sinon pourquoi ne pas utiliser QProcess ? L'api Windows est tout sauf intuitive et Qt facilite à mort ce genre d'opération.

[ternel]

J'ai tout autre chose a suggérer.

Il y a quelques années, il existait, au moins pour linux, une version bibliothèque de Gnuplot, utilisable directement dans un programme.

J'imagine que ca existe pour windows.

Cela te permettra de ne pas:

• utiliser un programme externe
• avoir à surveiller un tel programme.
• être dans un ensemble de programme qui ne s'enchainent pas
• tomber dans le problème des programmes qui créent un faux fichier avant de le remplir.

[kipgon]

Merci pour la suggestion du QProcess, je ne connaissais pas .

Je viens d'essayer, mais le résultat n'est pas aussi propre qu'avec WinExec. Je développe en fait avec WinExec, le programme est caché et seul apparait ma fenêtre (je j'ouvre plus tard avec mon image généré), mais avec le QProcess l'application s'ouvre "visuellement parlant".

[kipgon]

J'ai essayé toutes les configurations que j'ai pu imaginer mais je n'arrive pas à utiliser QProcess et cacher les fenêtres qui sont générées en même temps

J'ai essayé avec le handle

Code :

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

1
2
HWND hWnd = GetConsoleWindow();
ShowWindow( hWnd, SW_HIDE );

Avant et après mon

Code :

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

QProcess::start("gnuplot.exe fonction.gnu")

Mais je n'y arrive pas

C'est forcement possible non ? Je ne suis pas le seul à vouloir utiliser un programme extérieur, les créateurs de Qt y ont forcément pensé !

Pourtant je n'ai rien trouvé dans la doc

En plus c'est clair que ce serait mieux d'utiliser QProcess plutôt que l'API Windows car il y à un signal émit à la fin de l’exécution et ça me serait très utile pour résoudre mon problème principale qui est d'attendre la création de mon image pour continuer le processus !