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

GTK+ avec Python Discussion :

Relancer une application pygtk


Sujet :

GTK+ avec Python

  1. #1
    Membre confirmé
    Inscrit en
    Mai 2006
    Messages
    96
    Détails du profil
    Informations personnelles :
    Âge : 38

    Informations forums :
    Inscription : Mai 2006
    Messages : 96
    Par défaut Relancer une application pygtk
    Bonjour,

    Je cherche comment relancer une appli en pygtk a partir de cette même appli, dans le but de recharger la langue selectionnée.

    J'ai essayé en utilisant os.system("python monappli.py"), ca fonctionne mais l'ancienne appli ne se ferme pas et reste derrière, inactive.
    J'ai pourtant fait attention a ce que cet appel soit fait après le gtk.main_quit(), et que gtk.main() soit relancé, je ne comprend pas.

    en gros ce que je fait :

    main.py:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    MonAppli()
    gtk.main()
    if #teste si un fichier existe# :
        #destruction du fichier
        MonAppli()
        gtk.main()
    MonAppli:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    class MonAppli:
        #bla bla bla
        def relancer(self):
            #ecriture du fichier sur le disque
            gtk.main_quit()
    Une autre solution serait de lancer, dans MonAppli, une commande bash qui relancerait le main.py après x temp et de fermer gtk, mais je ne sais pas comment on fait ca en bash

    merci de votre aide.

  2. #2
    Membre chevronné
    Inscrit en
    Janvier 2007
    Messages
    329
    Détails du profil
    Informations forums :
    Inscription : Janvier 2007
    Messages : 329
    Par défaut
    Salut,

    Je pense que le plus simple serait de faire ça depuis bash, en utilisant les codes retour.
    Un programme qui se termine normalement renvoie un code retour 0. Tu peux faire en sorte que ton prog python renvoie une autre valeur (généralement on utilise des puissances de 2) quand la langue doit être changée.

    Exemple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    #!/bin/bash
    declare -i retour=128
    while (( retour == 128 )) ; do
        python tonprog.py
        retour=$?
    done
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    # tonprog.py
    import sys
    if change_langue == True:
        sys.exit(128)
    else:
        sys.exit(0)
    J'ai pas testé, mais ça devrait marcher...

  3. #3
    Membre confirmé
    Inscrit en
    Mai 2006
    Messages
    96
    Détails du profil
    Informations personnelles :
    Âge : 38

    Informations forums :
    Inscription : Mai 2006
    Messages : 96
    Par défaut
    Merci beaucoup !

    Par contre ca ne peut marcher que si j'appelle le fichier bash, si j'appelle directement dans une console le main.py ca ne peut plus marcher, j'aimerais bien faire ca uniquement en python, menfin c'est déjà une bonne solution.

    Petite précision, le sys.exit() je le met après le gtk.main_quit(), on est d'accord?

  4. #4
    Membre chevronné
    Inscrit en
    Janvier 2007
    Messages
    329
    Détails du profil
    Informations forums :
    Inscription : Janvier 2007
    Messages : 329
    Par défaut
    Oui, le sys.exit() termine ton programme. Tout ce qui est après ne sera pas exécuté.

    Y'a surement moyen de faire ça tout en python, mais je ne connais pas suffisamment les mécanismes qui entrent en jeu en lançant Gtk. Normalement, le ramasse-miettes détruit les objets qui ne sont plus utilisés, mais il peut rester des trucs qui font que ta classe reste instanciée...


    J'ai fait un truc qui semble marcher :
    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
     
    #!/usr/bin/python
    # -*- coding:utf-8 -*-
     
    import pygtk
    pygtk.require('2.0')
    import gtk
    import time
     
     
    class MonAppli(gtk.Window):
     
        def __init__(self, message):
            gtk.Window.__init__(self)
            self.set_default_size(400, 300)
            self.add(gtk.Label(message))
            self.connect('delete_event', self.ev_delete)
            self.connect('destroy', self.ev_destroy)
            self.set_title("Mon appli")
            self.show_all()
     
        def ev_delete(self, widget=None, event=None, data=None):
            return False
     
        def ev_destroy(self, widget=None, data=None):
            gtk.main_quit()
     
        def main(self):
            gtk.main()
            return 0
     
     
    if __name__ == "__main__":
        print "START"
        MonAppli("Salut !").main()
        time.sleep(2)
        MonAppli("Ca va bien ?").main()
        print "STOP"

  5. #5
    Membre confirmé
    Inscrit en
    Mai 2006
    Messages
    96
    Détails du profil
    Informations personnelles :
    Âge : 38

    Informations forums :
    Inscription : Mai 2006
    Messages : 96
    Par défaut
    J'ai essayé de m'inspirer de ton exemple, mais je n'arrive a rien, la deuxième fenêtre s'ouvre, dans la bonne langue, mais la première reste ouverte et active.

    je detaille un peu plus :

    main.py:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     
    f=open(G.FICHIER_ETAT,"w")
    f.close()
    if __name__ == '__main__':
        while os.path.isfile(G.FICHIER_ETAT):
            os.system("rm %s"%G.FICHIER_ETAT)
            app = Vue()
            app.main()
    vue.py:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    class Vue:
        def main(self):
            gtk.main()
            return 0
        #blablabla
        def delete(self, source=None, event=None,redemarrer=False):
            if redemarrer:
                print "redemarrage"
                f=open(G.FICHIER_ETAT,"w")
                f.close()
            gtk.main_quit()
    le signal "delete-event" est connecté a delete(), et lorsque je change de langue dans le programme une boite de confirmation s'ouvre et si l'utilisateur valide delete(redemarrer=true) est appelé.

    Tu vois ce qui cloche ?

    Autre précision : a quoi sert le "return 0" dans le main() ?

    Merci beaucoup !

  6. #6
    Membre chevronné
    Inscrit en
    Janvier 2007
    Messages
    329
    Détails du profil
    Informations forums :
    Inscription : Janvier 2007
    Messages : 329
    Par défaut
    Je crois savoir ce qui bloque : il manque un méchant "destroy" quelque part pour se débarrasser de l'ancienne fenêtre

    Par exemple, dans mon code, quand on demande de fermer l'application (clic sur la croix de la fenêtre dans mon cas), ça génère un 'delete-event'. Quand le callback d'un 'delete-event' renvoie "False" (comme chez moi), un évènement 'destroy' est automatiquement lancé, et il se charge de zigouiller proprement mon appli (et de faire le main_quit() dans mon cas).

    Normalement, on met les trucs du genre "êtes-vous sûr de vouloir quitter ?" (entre autres) dans le callback du 'delete-event', qui est appelé directement par le programme. Suivant s'il renvoie True ou False, ça quitte ou non l'application.


    Le "return 0", je sais pas, j'avais vu ça sur un tuto quand j'ai commencé à faire du pygtk, et j'ai fait du copier-coller...

  7. #7
    Membre confirmé
    Inscrit en
    Mai 2006
    Messages
    96
    Détails du profil
    Informations personnelles :
    Âge : 38

    Informations forums :
    Inscription : Mai 2006
    Messages : 96
    Par défaut
    Eh oui, c'etait bien un window.destroy() qui manquait, ca semble evident maintenant .

    Je trouve bizarre que l'ancienne fenêtre reste active malgrès tout...

    Bref, sujet résolu !

    merci pour ces précisions monnomamoi.

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

Discussions similaires

  1. relancer une application après une erreur critique
    Par d'Oursse dans le forum Windows
    Réponses: 9
    Dernier message: 10/01/2012, 15h17
  2. Réponses: 1
    Dernier message: 16/10/2008, 11h00
  3. relancer une application déja ouverte
    Par fally dans le forum C#
    Réponses: 10
    Dernier message: 12/03/2008, 19h49
  4. [D7] Une application qui se relance
    Par Moine dans le forum Débuter
    Réponses: 6
    Dernier message: 20/11/2007, 16h40
  5. Relancement d'une application
    Par cris73 dans le forum Prolog
    Réponses: 1
    Dernier message: 28/03/2007, 15h55

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