Vu qu'il faut une boucle testant d'ailleurs si la fenêtre est ouverte, je me suis toujours dit que ce n'été pas possible.C'est pas obligé, tu mets ce que tu veux comme condition d'arrêt. Par exemple, tu tournes tant que les deux fenêtres sont ouvertes.
J'y ai pensé à ta solution, mais imagine un programme où depuis la fenêtre principale, tu en crée une autre avec un bouton, il faut bien une boucle séparée pour les deux.Non pas forcément. Tu peux dans tous les cas garder une seule boucle principale qui gère toutes les fenêtres. Là j'ai mis un exemple avec deux "window1" et "window2", mais ça marcherait aussi avec un std::vector<sf::RenderWindow*> auquel tu pourrais ajouter dynamiquement des nouvelles fenêtres. Le tout c'est de toujours retomber dans la boucle principale, il ne faut jamais démarrer une autre boucle similaire toute seule dans son coin, qui bloquerait la boucle principale.
Pour Mac, les programmes comme Gimp font comment alors ? Puisque chaque fenêtre à sa propre boucle.Ah bon ? Comment tu sais ça ? Tu as regardé le code source de Gimp ? :P
Ou autre solution, les fenêtres en question sont créer dans le thread principal, mais les boucles sont dans des threads séparés. Tu penses que ça peut marcher ?Non. Comme je te l'ai dit (et comme expliqué dans le tutoriel sur les fenêtres), il faut gérer les évènements dans le même thread qui a créé la fenêtre.
Je verrais pour tester cet aprem car là je vais aller manger, sinon je testerais ce soir en arrivant à la maison. Parce que, que tout soit dans le même thread j'ai alors du mal à comprendre comment Qt/GTK font, à moins qu'ils crées la fenêtre dans le thread principal mais gère la boucle dans un thread séparé.Tu cherches vraiment compliqué alors qu'il n'y a aucun problème. Essaye de mieux comprendre le truc (et par "truc", j'entends "ce que tu penses être le problème") avant de te lancer dans des tests compliqués et inutiles ;)
Si on met une boucle commune, cela veut dire que fermer une fenêtre les fermes toutes.Pourquoi ? Tant que ton propre code ne dit pas de fermer les autres lorsqu'une est fermée, cela ne se produira pas. Je te l'ai dit, la condition qui stoppe la boucle principale, tu y mets ce que tu veux. Si c'est "boucler tant que la fenêtre principale est ouverte" plutôt que "bloquer tant que toutes les fenêtres sont ouvertes", et bien pas de souci, tu peux le faire aussi... C'est ton programme, tu codes ce que tu veux.
Ah bon ? Comment tu sais ça ? Tu as regardé le code source de Gimp ?
Pourquoi ? Tant que ton propre code ne dit pas de fermer les autres lorsqu'une est fermée, cela ne se produira pas. Je te l'ai dit, la condition qui stoppe la boucle principale, tu y mets ce que tu veux. Si c'est "boucler tant que la fenêtre principale est ouverte" plutôt que "bloquer tant que toutes les fenêtres sont ouvertes", et bien pas de souci, tu peux le faire aussi... C'est ton programme, tu codes ce que tu veux.
Par contre quelle est l'utilité de WaitEvent par rapport à PollEvent ?C'est principalement utilisé lorsque tu ne gardes que la gestion d'évènements dans le thread principal, et mets le rendu et la logique dans un autre thread. Du coup grace à WaitEvent, tu es certain que ton thread principal ne fait rien lorsqu'il n'a rien à faire ;)
Sinon pour revenir sur le sujet, c'est bien comme tu me dis si c'est codé en dur. Mais si je crée un programme permettant avec un simple bouton de créer une fenêtre (par exemple), comment l'inclure dans la boucle alors pour qu'elle puisse réagir à des événements (ou tout simplement quelle puisse afficher quelque chose en particulier) ? Parce que codé en dur c'est simple, mais de façon dynamique y doit bien y avoir un moyen non ?Tu peux par exemple utiliser un tableau dynamique (std::vector) de fenêtres, comme je l'ai mentionné précédemment.
Pourquoi ? Tant que ton propre code ne dit pas de fermer les autres lorsqu'une est fermée, cela ne se produira pas. Je te l'ai dit, la condition qui stoppe la boucle principale, tu y mets ce que tu veux. Si c'est "boucler tant que la fenêtre principale est ouverte" plutôt que "bloquer tant que toutes les fenêtres sont ouvertes", et bien pas de souci, tu peux le faire aussi... C'est ton programme, tu codes ce que tu veux.
Tu peux par exemple utiliser un tableau dynamique (std::vector) de fenêtres, comme je l'ai mentionné précédemment.
#include <string>
#include <vector>
#include <algorithm>
#include "make_unique_ptr_temp.h"
#include <SFML/Graphics.hpp>
class graphic_engine
{
public:
graphic_engine();
void addFrame(unsigned int width, unsigned int height, std::string title);
int getWindowListSize();
void poolEvent(const int val, sf::Event& e);
virtual ~graphic_engine();
protected:
private:
std::vector<std::unique_ptr<sf::RenderWindow>> windowList;
};graphic_engine::graphic_engine()
{
}
void graphic_engine::addFrame(unsigned int width, unsigned int height, std::string title)
{
windowList.push_back(make_unique<sf::RenderWindow>(sf::VideoMode(width, height), title));
}
int graphic_engine::getWindowListSize()
{
return windowList.size();
}
void graphic_engine::poolEvent(const int val, sf::Event& e)
{
if(windowList[val]->pollEvent(e))
{
if (e.type == sf::Event::Closed)
{
windowList[val]->close();
windowList.erase(std::remove(windowList.begin(), windowList.end(), windowList[val]), windowList.end());
}
}
}
graphic_engine::~graphic_engine()
{
//dtor
}int main()
{
graphic_engine* gs = new graphic_engine();
gs->addFrame(300,200,"fen1");
gs->addFrame(300,200,"fen2");
gs->addFrame(300,200,"fen3");
while (gs->getWindowListSize() != 0)
{
for(int i = 0; gs->getWindowListSize() > i; i++)
{
sf::Event event;
gs->poolEvent(i, event);
}
}
return 0;
}