IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

PyQt Python Discussion :

QDialog : exec et hide ?


Sujet :

PyQt Python

  1. #1
    Membre confirmé
    Homme Profil pro
    Inscrit en
    Novembre 2013
    Messages
    563
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Novembre 2013
    Messages : 563
    Points : 460
    Points
    460
    Par défaut QDialog : exec et hide ?
    Bonsoir,

    je viens chercher conseil auprès de vous (toujours bon !).

    Voila actuellement mon code
    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
        ### Creation de la fenetre
        GlobalVar["ProgressDialog"] = ProgressDialog(None, TotalSubtitles)
     
        ### Conversion des images en textes
        ## Création du thread
        MonProgressThread = ProgressThread()
     
        ## Connexion des signaux de progression et de fin du thread
        MonProgressThread.FinDuThread.connect(GlobalVar["ProgressDialog"].WorkFinish)
        MonProgressThread.ProgDuThread.connect(GlobalVar["ProgressDialog"].WorkProgression)
        MonProgressThread.PauseDuThread.connect(GlobalVar["ProgressDialog"].WorkPauseExt)
     
        ## Démarrage du thread
        MonProgressThread.start()
     
     
        ### Affichage de la fenêtre de progression
        GlobalVar["ProgressDialogClose"] = GlobalVar["ProgressDialog"].exec()
     
        ### Nettoyage du QThread ayant géré la conversion
        MonProgressThread.shutdown()
    le exec me permet donc de stopper temporairement la suite de commande.

    Ca fonctionne bien mais je voudrais ajouter l'affichage de la fenêtre facultative.

    la 1ere idée qui m'est venu est de la cacher avant de l’exécuter, mais cela ne fonctionne pas (dommage ça répondait à mes attentes :p).
    Ma 2eme idée est de modifier complètement le fonctionnement de mon soft en utilisant les signaux finished, accepted et rejected...

    Mais je me dis qu'il y a peut être une autre façon de faire plus simple :p

    Pour info que je l'affiche ou non, elle contient les même données et il y a des échanges d'infos à coup d'emit entre mon Thread et ma QDialog.

    en espérant avoir été clair (j'ai la tête en bouillie là) et dans l'attente de vos réponses, veuillez agréer...
    Sous Kubuntu 20.04

  2. #2
    Expert éminent

    Homme Profil pro
    Inscrit en
    Octobre 2008
    Messages
    4 300
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations forums :
    Inscription : Octobre 2008
    Messages : 4 300
    Points : 6 780
    Points
    6 780
    Par défaut
    Citation Envoyé par hizoka Voir le message
    Bonsoir,

    je viens chercher conseil auprès de vous (toujours bon !).

    Voila actuellement mon code
    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
        ### Conversion des images en textes
        ## Création du thread
        MonProgressThread = ProgressThread()
     
        ## Connexion des signaux de progression et de fin du thread
        MonProgressThread.FinDuThread.connect(GlobalVar["ProgressDialog"].WorkFinish)
        MonProgressThread.ProgDuThread.connect(GlobalVar["ProgressDialog"].WorkProgression)
        MonProgressThread.PauseDuThread.connect(GlobalVar["ProgressDialog"].WorkPauseExt)
     
        ## Démarrage du thread
        MonProgressThread.start()
     
     
        ### Affichage de la fenêtre de progression
        GlobalVar["ProgressDialogClose"] = GlobalVar["ProgressDialog"].exec()
     
        ### Nettoyage du QThread ayant géré la conversion
        MonProgressThread.shutdown()
    le exec me permet donc de stopper temporairement la suite de commande.
    Quel exec ?

    Ca fonctionne bien mais je voudrais ajouter l'affichage de la fenêtre facultative.
    Quelle fenêtre facultative ?

    la 1ere idée qui m'est venu est de la cacher avant de l’exécuter, mais cela ne fonctionne pas (dommage ça répondait à mes attentes :p).
    Ma 2eme idée est de modifier complètement le fonctionnement de mon soft en utilisant les signaux finished, accepted et rejected...

    Mais je me dis qu'il y a peut être une autre façon de faire plus simple :p

    Pour info que je l'affiche ou non, elle contient les même données et il y a des échanges d'infos à coup d'emit entre mon Thread et ma QDialog.

    en espérant avoir été clair (j'ai la tête en bouillie là) et dans l'attente de vos réponses, veuillez agréer...

    Franchement, Hizoka, tu es incompréhensible sur ce coup. Et qu'est-ce que ce GlobalVar["ProgressDialog"] ?

  3. #3
    Membre confirmé
    Homme Profil pro
    Inscrit en
    Novembre 2013
    Messages
    563
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Novembre 2013
    Messages : 563
    Points : 460
    Points
    460
    Par défaut
    Ouais désolé, pas beaucoup dormi avec ma garde... du coup je suis moins explicite que d’habitude... (quoi que...)

    Quel exec ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    GlobalVar["ProgressDialogClose"] = GlobalVar["ProgressDialog"].exec()
    C'est l’exécution de ma fenêtre QDialog

    Quelle fenêtre facultative ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    GlobalVar["ProgressDialogClose"] = GlobalVar["ProgressDialog"].exec()
    Je souhaite que l'affichage de cette fenêtre deviennent facultative, qu'elle reste présente mais cachée finalement...
    je voulais mettre un
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    if blabla:
      GlobalVar["ProgressDialog"].hide()
    avant son execution.

    Et qu'est-ce que ce GlobalVar["ProgressDialog"] ?
    j'ai ajouté :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
        ### Creation de la fenetre
        GlobalVar["ProgressDialog"] = ProgressDialog(None, TotalSubtitles)
    c'est ma fameuse fenêtre QDialog que je souhaite ne pas afficher.

    J’espère que quand je me relirai, une fois reposé, je ne me dirai pas : "Ouhaaa, carrément à l'ouest l'hizoka..." :p
    Sous Kubuntu 20.04

  4. #4
    Expert éminent
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    Décembre 2007
    Messages
    4 462
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2007
    Messages : 4 462
    Points : 9 249
    Points
    9 249
    Billets dans le blog
    6
    Par défaut
    Bonjour hizoka,

    Les méthodes hide et show fonctionnent avec la fenêtre QProgressDialog, car elle hérite de QWidget.

    Je viens d'en faire l'essai de cette façon avec un de mes codes qui utilise un thread:

    - pour hide: j'ai sous-classé QProgressDialog pour lui ajouter un raccourci clavier: Alt-S => self.hide()

    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
    class ProgressDialog(QtWidgets.QProgressDialog):
     
        #========================================================================
        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)
     
        # =======================================================================
        def keyPressEvent(self, event):
            """raccourcis clavier
            """
            # Alt-S => cache la fenêtre QProgressDialog
            if event.key() == QtCore.Qt.Key_H and (event.modifiers() & QtCore.Qt.AltModifier):
                self.hide()
                event.accept()
            else:
                event.ignore()
    - Pour show(), quand la fenêtre de progressdialog est cachée, elle n'a plus le focus, et donc ne peut pas recevoir de commande clavier. J'ai donc ajouté le raccourci clavier à la fenêtre qui a lancé le progressdialog et qui a le focus quand cette fenêtre a été cachée: Als-S => self.prog.show()

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
        def keyPressEvent(self, event):
            """raccourcis clavier
            """
            # Alt-S => affiche la fenêtre QProgressDialog
            if event.key() == QtCore.Qt.Key_S and (event.modifiers() & QtCore.Qt.AltModifier):
                self.prog.show()
                event.accept()
            else:
                event.ignore()
    Avec ça, le test marche: pendant l'affichage de la progression, on cache et on ré-affiche la fenêtre de progression à volonté. Ce faisant, on voit bien que la fenêtre progressdialog continue à être active quand elle est cachée (=la barre de progression avance grâce au thread).

    La conclusion, c'est que tu dois trouver en fonction de ton code comment actionner hide() et show() pour que ça marche chez toi.

    Cependant, à mon avis, tu devrais essayer de lancer la fenêtre progressdialog avec show() et non exec(), car la méthode exec() met la fenêtre en mode "modal" exclusif, et il est possible que ça bloque ce genre de manip. En tout cas, c'est ce qui se passe chez moi. Si tu veux que la fenêtre soit modale, tu peux utiliser ceci avant le show():

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    self.prog.setWindowModality(QtCore.Qt.ApplicationModal)
    Un expert est une personne qui a fait toutes les erreurs qui peuvent être faites, dans un domaine étroit... (Niels Bohr)
    Mes recettes python: http://www.jpvweb.com

  5. #5
    Membre confirmé
    Homme Profil pro
    Inscrit en
    Novembre 2013
    Messages
    563
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Novembre 2013
    Messages : 563
    Points : 460
    Points
    460
    Par défaut
    Salut et merci de ta réponse.

    Pour info c'est une QDialog maison qui remplace la QProgressDialog, mais ça ne doit pas changer grand chose.

    Tu m'as donné l'idée de tester :
    execution de la fenêtre
    bouton hide
    => la fenêtre est considérée comme fermée, le code continue
    C'est l'explication du pourquoi du comment je ne peux la cacher et l’exécuter

    Il va donc falloir que je parte vers show() en effet mais du coup cela ne bloque pas mon code (comme le fait exec()) et donc ça fout en l'air mon fonctionnement linéaire (mes commandes suivantes sont exécutées avant la fermeture de la fenêtre).

    il faut donc que je modifie le fonctionnement de soft.


    EDIT : après tests, je ne vois pas trop comment faire.

    Et vu que je ne suis pas forcément très clair, ça sera peut être un peu plus facile pour vous de voir plus de commandes.

    Je me permets de vous joindre mon script (il reste du travail dessus, des modifications de noms de variables et autres)
    Ligne 1660, j'ai essayé de détailler le problème
    Si quelqu'un a une idée.

    Désolé si ça vous parait pas clair/logique et merci beaucoup à vous.
    Fichiers attachés Fichiers attachés
    Sous Kubuntu 20.04

  6. #6
    Expert éminent
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    Décembre 2007
    Messages
    4 462
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2007
    Messages : 4 462
    Points : 9 249
    Points
    9 249
    Billets dans le blog
    6
    Par défaut
    Citation Envoyé par hizoka Voir le message
    Il va donc falloir que je parte vers show() en effet mais du coup cela ne bloque pas mon code (comme le fait exec()) et donc ça fout en l'air mon fonctionnement linéaire (mes commandes suivantes sont exécutées avant la fermeture de la fenêtre)
    En fait, il y a une différence importante entre show() et exec(). Comme tu l'as vu, exec() ne fait pas que d'afficher la fenêtre de dialogue, elle bloque l'exécution des instructions suivantes, et en plus, elle exécute une boucle spéciale de traitement des évènements (et celle de la fenêtre normale ne s'exécute plus). D'habitude, c'est bien ce qu'on veut. Par exemple, pour demander un nom de fichier avec un QFileDialog qui n'est pas celui de l'OS, on utilise bien exec(), et les lignes d'instructions qui suivent attendent que la réponse ait été faite et la fenêtre de dialogue fermée pour continuer à s'exécuter.

    Ce n'est pas le cas ici: on veut lancer la fenêtre de dialogue pour avoir la barre de progression, mais le programme doit pouvoir continuer à s'exécuter!
    Un expert est une personne qui a fait toutes les erreurs qui peuvent être faites, dans un domaine étroit... (Niels Bohr)
    Mes recettes python: http://www.jpvweb.com

  7. #7
    Membre confirmé
    Homme Profil pro
    Inscrit en
    Novembre 2013
    Messages
    563
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Novembre 2013
    Messages : 563
    Points : 460
    Points
    460
    Par défaut
    bah non, le programme central ne doit pas continuer, juste le QThread qui envoie les infos à la progressbar.

    C'est donc ma façon de faire qui n'est pas la bonne, je détourne l'utilisation de exec ?
    car très clairement, cela fait exactement ce que je veux ainsi (tant que je ne veux pas rendre l'affichage de la fenêtre facultatif :p )

    Mon système linéaire d’exécution du code n'est donc pas la bonne manière ?
    Ca me paraissait logique à partir du moment ou je voulais faire 2 modes (1 avec l’affichage des fenêtres et l'un sans en conservant les mêmes fonctionnements)

    Désolé d'être borné XD mais plus j'ai d'explications plus je suis content

    Edit : Bah j'ai modifié le fonctionnement du script et maintenant il fait comme mes autres soft (les classes et fonctions s'appellent les uns après les autres) et ça semble ok
    C'est dommage ça faisait très "bash" :p
    Merci à vous.
    Sous Kubuntu 20.04

  8. #8
    Expert éminent
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    Décembre 2007
    Messages
    4 462
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2007
    Messages : 4 462
    Points : 9 249
    Points
    9 249
    Billets dans le blog
    6
    Par défaut
    Citation Envoyé par hizoka Voir le message
    bah non, le programme central ne doit pas continuer, juste le QThread qui envoie les infos à la progressbar.

    C'est donc ma façon de faire qui n'est pas la bonne, je détourne l'utilisation de exec ?
    car très clairement, cela fait exactement ce que je veux ainsi (tant que je ne veux pas rendre l'affichage de la fenêtre facultatif :p )

    Mon système linéaire d’exécution du code n'est donc pas la bonne manière ?
    Ca me paraissait logique à partir du moment ou je voulais faire 2 modes (1 avec l’affichage des fenêtres et l'un sans en conservant les mêmes fonctionnements)

    Désolé d'être borné XD mais plus j'ai d'explications plus je suis content
    Je ne comprends pas ce que tu entends par "système linéaire d’exécution du code". Le mode de fonctionnement d'un programme graphique est toujours le même: il y a une boucle permanente d'attente des évènements (le "app.exec_()"), et des traitements au fur et à mesure des demandes (bouton, messages, clavier, souris, etc...). Donc, à part quand on attend la réponse de l'utilisateur en utilisant "exec()" (cf le cas de QFileDialog), chaque exécution de méthode doit rendre la main à la boucle des évènements le plus vite possible. A défaut, la fenêtre du programme "freeze".

    Dans le cas de la boucle de progression avec un travail qui s'exécute sous thread, voilà le principe que j'utilise:

    - on considère la fenêtre principale de l'application qui doit lancer le thread et le progressdialog.

    - la méthode de lancement du travail de cette fenêtre principale lance la fenêtre progressdialog suivi immédiatement du thread avec ses connexions (connect) pour la mise à jour de la progression et la fin du thread, et rend tout de suite la main à la boucle des évènements.

    - pendant l'exécution du thread, celui-ci envoie un message de progression (emit) qui exécute la méthode prévue de la fenêtre principale et c'est cette méthode qui met à jour le progressdialog.

    - à la fin de l'exécution du thread, celui-ci envoie un message de fin (emit) qui exécute l'autre méthode prévue de la fenêtre et cette méthode "fait le ménage" en arrêtant le progressdialog et en rompant les liens du thread avec les méthodes de la fenêtre principale (disconnect).

    C'est, à mon avis la seule façon de faire. Avec show() au lieu de exec(), le thread peut être lancé dans la foulée et s'exécuter, ses informations envoyées aux méthodes prévues qui ne sont pas bloquées et qui répercutent ce qu'il faut au progressdialog.


    J'ai déjà dû donner ce genre de code ici, mais si tu le souhaites, je peux en redonner, et on pourra en discuter.
    Un expert est une personne qui a fait toutes les erreurs qui peuvent être faites, dans un domaine étroit... (Niels Bohr)
    Mes recettes python: http://www.jpvweb.com

  9. #9
    Membre confirmé
    Homme Profil pro
    Inscrit en
    Novembre 2013
    Messages
    563
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Novembre 2013
    Messages : 563
    Points : 460
    Points
    460
    Par défaut
    Merci pour cette réponse, je la relirai et te répondrai demain car je suis de mariage

    grand merci pour ta présence ici !!
    Sous Kubuntu 20.04

  10. #10
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 287
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 287
    Points : 36 776
    Points
    36 776
    Par défaut
    Salut,

    Citation Envoyé par hizoka Voir le message
    Mon système linéaire d’exécution du code n'est donc pas la bonne manière ?
    Ca me paraissait logique à partir du moment ou je voulais faire 2 modes (1 avec l’affichage des fenêtres et l'un sans en conservant les mêmes fonctionnements)
    Ce qui rend l'exécution séquentielle sont les paires .exec_() / .quit().
    Comme je ne connais que le code que j'avais posté tantôt, j'y faisais dialog.exec_() qui bloque tant que le thread ne poste pas un .quit.
    Mais si on veut rendre l'affichage de la progress bar "optionnelle" et garder la logique (çà bloque), il suffit de planter l'.exec_ sur l'objet thread (qu'on aura toujours contrairement au dialog qui est maintenant optionnel).
    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
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    from concurrent.futures import ThreadPoolExecutor as Pool
    import subprocess
    from PyQt5.QtCore import QThread, pyqtSignal
     
    class Launcher(QThread):
        on_update = pyqtSignal(float)
        on_done = pyqtSignal()
        _abort = False            
        _dialog = None
     
        def __init__(self, count=10, display_dialog=True):
            super().__init__()
            self.count = count
            if display_dialog:
                dialog = self._dialog = QProgressDialog("En cours...", "Annuler", 0, 100)
                self.on_update.connect(dialog.setValue)
                self.on_done.connect(dialog.reset)
                dialog.show()
     
            self.on_done.connect(self.shutdown)
        def run_item(self, ident):
            if not self._abort:
                subprocess.call ('python -c "import time; time.sleep(0.5)"')
                return ident
     
        def run(self):
     
            step = 100 / self.count
            done = 0
     
            def callback(future):
                nonlocal done
                if not self._abort:
                    done += step
                    print('callback', done, 'ix', future.result())
                    self.on_update.emit(done)
                    if done >= 100 :
                       self.on_done.emit()
     
     
            self.futures = {}
            pool = self.pool = Pool(max_workers=2)
     
            for z in range(self.count):
                future = pool.submit(self.run_item, z)
                future.add_done_callback(callback)
                self.futures[z] = future
     
     
        def shutdown(self):  # ** too much **
            self._abort = True
    #         for f in self.futures.values():
    #             f.cancel()
            self.pool.shutdown(wait=True)
            self.exit()
     
     
     
    if __name__ == '__main__':
        from PyQt5.QtWidgets import QApplication, QProgressDialog, QPushButton
     
        def do_launch():
            launcher = Launcher(display_dialog=False)
    #         dialog = QProgressDialog("En cours...", "Annuler", 0, 100)
    #         launcher.on_update.connect(dialog.setValue)
    #         launcher.on_done.connect(dialog.reset)
            launcher.start()  
     
            launcher.exec_()   
    #         launcher.shutdown()
     
     
        app = QApplication([])
     
        btn = QPushButton('start')
        btn.clicked.connect(do_launch)
        btn.show()
     
        exit(app.exec_())
    et voilà.

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  11. #11
    Membre confirmé
    Homme Profil pro
    Inscrit en
    Novembre 2013
    Messages
    563
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Novembre 2013
    Messages : 563
    Points : 460
    Points
    460
    Par défaut
    tyrtamos :
    En fait à la base c'était un script sans interface graphique au quel j'ai ajouté différentes fenetres, du coup c'était du genre :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    commande 1
    commande 2
    commande 3
    fenetre bloquante (exec)
    commande 4
    commande 5
    fenetre bloquante (exec)
    commande 6
    donc un modele assez different d'un soft prévu dés le début pour de l'interface graphique comme tu le décris et pour lesquels tu as déjà posté des exemples (très utile !)


    wiztricks :
    Pas mal l'exec sur le QThread
    en effet du coup ça fonctionne.


    Merci beaucoup à vous 2 pour tout ce que vos m'apportez avec vos réponses !
    Sous Kubuntu 20.04

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [Graphics View] Fermeture de QDialog impossible après exec()
    Par defrouille dans le forum Qt
    Réponses: 8
    Dernier message: 12/01/2011, 18h33
  2. [RUNTIME][EXEC]
    Par adrien1977 dans le forum API standards et tierces
    Réponses: 7
    Dernier message: 30/09/2009, 16h28
  3. [Free Pascal] Comportement de Exec
    Par néo333 dans le forum Free Pascal
    Réponses: 3
    Dernier message: 01/11/2003, 17h46
  4. Comment utiliser Site Exec sous FTP
    Par phig dans le forum Développement
    Réponses: 2
    Dernier message: 12/08/2003, 17h11
  5. [POSTGRESQL] exec function
    Par peuh dans le forum Requêtes
    Réponses: 5
    Dernier message: 23/05/2003, 15h15

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo