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

GUI Python Discussion :

[kivy] Liste réinitialisée avec ScreenManager


Sujet :

GUI Python

  1. #1
    Membre actif
    Profil pro
    Inscrit en
    février 2003
    Messages
    896
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : février 2003
    Messages : 896
    Points : 267
    Points
    267
    Par défaut [kivy] Liste réinitialisée avec ScreenManager
    Bonjour,

    j'utilise Kivy et je pensais pouvoir utiliser une liste pour transmettre des paramètres lors de changement de fenêtre avec screenmanager. Or je m'aperçois que lorsque je modifie une liste et qu'ensuite je clique pour passer à l'écran suivant, ma liste est réinitialisée. Sauriez-vous comment remédier à ce problème svp?

    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
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    import kivy
    kivy.require('1.9.0')
     
    from kivy.app import App
    from kivy.uix.screenmanager import ScreenManager, Screen
    from kivy.uix.gridlayout import GridLayout
    from kivy.uix.button import Button
    from kivy.uix.label import Label
    from kivy.config import Config
     
     
    #Config.set('graphics', 'width', '1366') 
    #Config.set('graphics', 'height', '768') 
     
    Config.set('graphics', 'fullscreen', 'auto') 
     
    ecran4=["0"]
    myBtn=[]
    monText=["Ce bouton devrait afficher \"Thé\" ou \"Café\""]
     
     
    class ScreenOne(Screen):
     
        def __init__(self, **kwargs):
     
            def do_action(self):
     
                if play.text=="Café" :
                    play.text="Thé"
                    monText[:]=[]
                    monText.append("Thé")
                    print("Thea : "+str(monText[0]))
                else :
                    play.text="Café"
                    monText[:]=[]
                    monText.append("Café")
                    print("Coffee : "+str(monText[0]))
            pass
     
            def do_action2(self):
               screen_manager.transition.direction = 'left'
               screen_manager.transition.duration = 0
               screen_manager.current = 'screen_two'
            pass
     
            super(ScreenOne, self).__init__(**kwargs)
            Layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(Layout1)
            play = Label(text = "Café")
            Layout1.add_widget(play)
            myBtn.append(play)
            changing = Layout1.add_widget(Button(text = "Changement", on_press=do_action))
            clickBtn = Button(text = "OK", on_press=do_action2)
            Layout1.add_widget(clickBtn)
     
    class ScreenTwo(Screen):    
     
        def __init__(self, **kwargs):
     
            def do_action2(self):
                screen_manager.transition.direction = 'left'
                screen_manager.transition.duration = 0
                screen_manager.current = 'screen_one'
            pass
     
            super(ScreenTwo, self).__init__(**kwargs)
            ScreenTwo.clear_widgets(self)
            Layout2 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(Layout2)
     
            print(monText[0])
     
            for nbBtn in range(10):
                monChoix = Button(text = monText[0], on_press=do_action2)
                Layout2.add_widget(monChoix)
                myBtn.append(monChoix)       
     
     
    # The ScreenManager controls moving between screens
    screen_manager = ScreenManager()
     
    # Add the screens to the manager and then supply a name
    # that is used to switch screens
    screen_manager.add_widget(ScreenOne(name="screen_one"))
    screen_manager.add_widget(ScreenTwo(name="screen_two"))
     
    class KivyTut2App(App):
     
        def build(self):
            screen_manager.current = 'screen_one' 
            return screen_manager
     
    sample_app = KivyTut2App()
    sample_app.run()

  2. #2
    Expert éminent

    Homme Profil pro
    Inscrit en
    octobre 2008
    Messages
    3 840
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations forums :
    Inscription : octobre 2008
    Messages : 3 840
    Points : 6 020
    Points
    6 020
    Par défaut
    Salut,

    Tu parles de la liste monText ?

    On se demande à quoi elle sert, mais de toutes façons tu la recrées vide à chaque action, donc elle ne peut contenir qu'un seul terme.

  3. #3
    Membre éprouvé

    Homme Profil pro
    ValueError
    Inscrit en
    avril 2016
    Messages
    689
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : ValueError

    Informations forums :
    Inscription : avril 2016
    Messages : 689
    Points : 1 018
    Points
    1 018
    Billets dans le blog
    1
    Par défaut
    Salut.

    "Ce bouton devrait afficher \"Thé\" ou \"Café\""
    Tes boutons sont créés à l'instance de ta classe ScreenTwo, et c'est pas en modifiant ta liste que les textes des boutons vont se mettre à jour par magie. T'es quand même très mal parti, le principe de la poo n'est pas de tout fourrer dans l'init des classes en espérant que ça marche, avec des bouts de codes glanés ici et là, si tu ne structures pas ton code correctement dès le départ tu vas droit dans le mur. Il serait quand même judicieux de suivre un tutoriel sur comment coder en poo, ça ne s'improvise pas, cela demande beaucoup de temps d'apprentissage, de tests, avant de s'attaquer à une bibliothèque complexe comme kivy.
    Le temps ronge l'amour comme l'acide.

  4. #4
    Membre actif
    Profil pro
    Inscrit en
    février 2003
    Messages
    896
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : février 2003
    Messages : 896
    Points : 267
    Points
    267
    Par défaut
    Merci pour vos réponses. Je pense que je suis sur la bonne voie. J'ai créé ce code qui montre comment faire passer une liste d'un écran à un autre, éventuellement la modifier, puis la repasser à un autre et ainsi de suite. Dès que j'aurai ma solution, je la posterai.

    Le problème que je rencontre est que je ne peux pas faire usage de la liste au moment du transfert (changement d'écran), pour par exemple remplacer le texte du bouton par le premier élément de la liste.

    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
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    from kivy.app import App
    from kivy.uix.screenmanager import ScreenManager, Screen
    from kivy.uix.gridlayout import GridLayout
    from kivy.uix.button import Button
    
    class Screen1(Screen):
    
        list = [1,2,3]
    
    
        def __init__(self,**kwargs):
    
            super(Screen1,self).__init__(**kwargs)
            self.switch_button = Button(text="ECRAN 1 : goto 2")
            self.switch_button.bind(on_release=self.switch)
            self.add_widget(self.switch_button)
    
        def switch(self,*args):
            self.list = [4,5,6]
            self.manager.get_screen("screen2").list = list(self.list)
            self.manager.current = "screen2"
            
        def on_enter(self):
            print ("écran 1 : "+ str(self.list))
            #print (self.list)
    
    class Screen2(Screen):    
    
        def __init__(self,**kwargs):
    
            super(Screen2,self).__init__(**kwargs)
            Layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(Layout1)
            Layout1.switch_button = Button(text="ECRAN 2 : goto 3")
            Layout1.switch_button.bind(on_release=self.switch)
            Layout1.add_widget(Layout1.switch_button)
            Layout1.switch2_button = Button(text="Print List")
            Layout1.switch2_button.bind(on_release=self.switch2)
            Layout1.add_widget(Layout1.switch2_button)
            Layout1.switch3_button = Button(text="Modifier List")
            Layout1.switch3_button.bind(on_release=self.switch3)
            Layout1.add_widget(Layout1.switch3_button)        
    
        def switch(self,*args):
            self.manager.get_screen("screen3").list = list(self.list)
            self.manager.current = "screen3"
            print(self.list)
    
        def switch2(self,*args):
            print(self.list)
    
        def switch3(self,*args):
            self.list = [8,9,10]
            self.manager.get_screen("screen3").list = list(self.list)
            self.manager.current = "screen3"
            
            
    
        def on_enter(self):
            print ("écran 2 : "+ str(self.list))
            #print (self.list)
    
        
    
    
    class Screen3(Screen):
        
        def __init__(self,**kwargs):        
    
            def myList(self):
                pass
                #print(self.list)
    
    
            super(Screen3,self).__init__(**kwargs)
            Layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(Layout1)
            Layout1.switch_button = Button(text="ECRAN 3 : goto 1")
            Layout1.switch_button.bind(on_release=self.switch)
            Layout1.add_widget(Layout1.switch_button)
            Layout1.switch2_button = Button(text="Print List")
            Layout1.switch2_button.bind(on_release=self.switch2)
            Layout1.add_widget(Layout1.switch2_button)
            
        def switch(self,*args):
            self.manager.get_screen("screen1").list = list(self.list)        
            self.manager.current = "screen1"
    
        def switch2(self,*args):
            print(self.list)        
    
        def on_enter(self):                         
            print ("écran 3 : "+ str(self.list))   
    
    
    class MainApp(App):
    
        def build(self):
    
            sc1 = Screen1(name="screen1")
            sc2 = Screen2(name="screen2")        
            sc3 = Screen3(name="screen3")
    
            self.sm = ScreenManager()
    
            self.sm.add_widget(sc1)
            self.sm.add_widget(sc2)
            self.sm.add_widget(sc3)
    
            return self.sm
    
    
    MainApp().run()

  5. #5
    Membre éprouvé

    Homme Profil pro
    ValueError
    Inscrit en
    avril 2016
    Messages
    689
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : ValueError

    Informations forums :
    Inscription : avril 2016
    Messages : 689
    Points : 1 018
    Points
    1 018
    Billets dans le blog
    1
    Par défaut
    Salut.

    Pour partager un objet (des objets) entre plusieurs objet, bah un simple héritage suffit à le faire.

    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
    class Base :
        liste = [1, 2, 3]
     
        def voirListe(self) :
            print(self.liste)
     
    class A(Base) :
        def modifierListe(self) :
            self.liste[:2] = 6, 7
     
    class B(Base) :
        def modifierListe(self) :
            self.liste[:2] = 8, 9
     
    a = A()
    b = B()
    print('instances')
    a.voirListe()
    b.voirListe()
    print('modif a')
    a.modifierListe()
    a.voirListe()
    b.voirListe()
    print('modif b')
    b.modifierListe()
    a.voirListe()
    b.voirListe()
    Ce qui dans ton code reviendrait à créer une classe dérivée de Screen, qui pourrait avoir comme allure un truc comme.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class CustomScreen(Screen) :
        liste = [1, 2, 3]
     
        def switch(self, screen_name) :
            self.manager.current = screen_name
     
        def on_enter(self) :
            print('Écran :', self.manager.current)
            self.show_list()
            print('\n')
     
        def show_list(self) :
            print('Liste :', self.liste)
    Et que donc tes classes Screen* hériteraient au lieu de Screen.

    Sachant que on_enter est appelé lors du changement d'écran, rien ne t'empeĉhe de mettre à jour tes boutons dans cette méthode.
    Le temps ronge l'amour comme l'acide.

  6. #6
    Modérateur

    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2008
    Messages
    14 468
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 14 468
    Points : 24 478
    Points
    24 478
    Par défaut
    Citation Envoyé par Arsene12 Voir le message
    J'ai créé ce code qui montre comment faire passer une liste d'un écran à un autre, éventuellement la modifier, puis la repasser à un autre et ainsi de suite. Dès que j'aurai ma solution, je la posterai.
    Les différences avec le code précédent sont que la variable globale est devenue variable de classe, mais comme vous ne la ré-initialisez plus... c'est tombé en marche.

    Pour partager un objet entre plusieurs instances le passer en paramètre à la création de l'instance est quand même le plus naturel:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
        def build(self):
            liste = [1, 2, 3]
            sc1 = Screen1(liste, name="screen1")
            sc2 = Screen2(liste, name="screen2")        
            sc3 = Screen3(liste, name="screen3")
    Puis de l'attraper lors de l' initialisation:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    class Screen2(Screen):    
     
        def __init__(self, liste, **kwargs):
             self.liste = liste
             super().__init__(**kwargs)
             ...
    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  7. #7
    Membre actif
    Profil pro
    Inscrit en
    février 2003
    Messages
    896
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : février 2003
    Messages : 896
    Points : 267
    Points
    267
    Par défaut
    Citation Envoyé par wiztricks Voir le message
    Les différences avec le code précédent sont que la variable globale est devenue variable de classe, mais comme vous ne la ré-initialisez plus... c'est tombé en marche.

    Pour partager un objet entre plusieurs instances le passer en paramètre à la création de l'instance est quand même le plus naturel.
    Merci. J'ai appliqué vos instructions. Je déclare la liste dans tous les écrans de ScreenManager. Mais lorsque je passe de l'écran 1 à l'écran 2 en modifiant la liste, je récupère la liste initiale alors que je veux récupérer la liste modifiée. Le problème reste le même.

    Si on modifie la liste en cliquant sur "Modifier Liste" sur le 2ème écran, puis qu'on passe à l'écran 3, on récupère toujours la liste initiale.


    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
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    from kivy.app import App
    from kivy.uix.screenmanager import ScreenManager, Screen
    from kivy.uix.gridlayout import GridLayout
    from kivy.uix.button import Button
    
    class Screen1(Screen):
    
        def __init__(self, liste, **kwargs):
    
            super(Screen1,self).__init__(**kwargs)
            self.switch_button = Button(text="ECRAN 1 : goto 2")
            self.switch_button.bind(on_release=self.switch)
            self.add_widget(self.switch_button)
    
        def switch(self,*args):
            self.liste = [4,5,6]
            self.manager.get_screen("screen2").list = list(self.liste)
            self.manager.current = "screen2"
            
        def on_enter(self):
            pass
            #print ("écran 1 : "+ str(maList))
            #print (self.list)
    
    class Screen2(Screen):    
    
        def __init__(self, liste, **kwargs):
            self.liste = liste
            print(self.liste)
            super(Screen2, self).__init__(**kwargs)
            
            Layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(Layout1)
            Layout1.switch_button = Button(text="ECRAN 2 : goto 3")
            Layout1.switch_button.bind(on_release=self.switch)
            Layout1.add_widget(Layout1.switch_button)
            Layout1.switch2_button = Button(text="Print List")
            Layout1.switch2_button.bind(on_release=self.switch2)
            Layout1.add_widget(Layout1.switch2_button)
            Layout1.switch3_button = Button(text="Modifier Liste")
            Layout1.switch3_button.bind(on_release=self.switch3)
            Layout1.add_widget(Layout1.switch3_button)        
    
        def switch(self,*args):
            self.manager.get_screen("screen3").list = list(self.liste)
            self.manager.current = "screen3"
            ##print(self.list)
    
        def switch2(self,*args):
            pass
            print(self.liste)
    
        def switch3(self,*args):
            self.liste = [8,9,10]
            print(self.liste)
    
        def on_enter(self):
            pass
            #print ("écran 2 : "+ str(self.list))
            print (self.liste)
    
    class Screen3(Screen):
        
        def __init__(self, liste, **kwargs):        
            self.liste = liste
            def myList(self):
                pass
                ##print(self.list)
    
            super(Screen3,self).__init__(**kwargs)
            Layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(Layout1)
            Layout1.switch_button = Button(text="ECRAN 3 : goto 1")
            Layout1.switch_button.bind(on_release=self.switch)
            Layout1.add_widget(Layout1.switch_button)
            Layout1.switch2_button = Button(text="Print List")
            Layout1.switch2_button.bind(on_release=self.switch2)
            Layout1.add_widget(Layout1.switch2_button)
            
        def switch(self,*args):
            self.manager.get_screen("screen1").list = list(self.liste)        
            self.manager.current = "screen1"
    
        def switch2(self,*args):
            pass
            print(self.liste)        
    
        def on_enter(self):
            pass
            print ("écran 3 : "+ str(self.liste))   
    
    class MainApp(App):
    
        def build(self):
    
            liste = [1, 2, 3]
            sc1 = Screen1(liste, name="screen1")
            sc2 = Screen2(liste, name="screen2")        
            sc3 = Screen3(liste, name="screen3")
    
            self.sm = ScreenManager()
    
            self.sm.add_widget(sc1)
            self.sm.add_widget(sc2)
            self.sm.add_widget(sc3)
    
            return self.sm
    
    MainApp().run()
    Je trouve ScreenManager très bien mais s'il me scratche mas variables je vais devoir l'abandonner et je le regrette.

    Quand je réinitialise l'écran 2 dans la "class Screen 1" après avoir modifié la liste, je la transfère bien dans la "class 2", mais elle se réinitialise avec le super(Screen2, self)

    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
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    from kivy.app import App
    from kivy.uix.screenmanager import ScreenManager, Screen
    from kivy.uix.gridlayout import GridLayout
    from kivy.uix.button import Button
    
    class Screen1(Screen):
    
        def __init__(self, liste, **kwargs):
            self.liste = liste
            super(Screen1,self).__init__(**kwargs)
            self.switch_button = Button(text="ECRAN 1 : goto 2")
            self.switch_button.bind(on_release=self.switch)
            self.add_widget(self.switch_button)
    
        def switch(self,*args):
            liste = [4,5,6]
            #self.manager.get_screen("screen2").list = list(liste)
            sc2 = Screen2(liste, name="screen2") 
            self.manager.current = "screen2"
            
        def on_enter(self):
            pass
            print ("écran 1 : "+ str(self.liste))
            #print (self.list)
    
    class Screen2(Screen):
    
        def __init__(self, liste, **kwargs):
            self.liste = liste
            maList = liste
            print(liste)
            print(maList)
            
            super(Screen2, self).__init__(**kwargs)        
            Layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(Layout1)
            Layout1.switch_button = Button(text="ECRAN 2 : goto 3")
            Layout1.switch_button.bind(on_release=self.switch)
            Layout1.add_widget(Layout1.switch_button)
            Layout1.switch2_button = Button(text="Print List")
            Layout1.switch2_button.bind(on_release=self.switch2)
            Layout1.add_widget(Layout1.switch2_button)
            Layout1.switch3_button = Button(text="Modifier List")
            Layout1.switch3_button.bind(on_release=self.switch3)
            Layout1.add_widget(Layout1.switch3_button)
            Layout1.switch_button = Button(text=str(maList))
            Layout1.switch_button.bind(on_release=self.switch)
            Layout1.add_widget(Layout1.switch_button)
    
        def switch(self,*args):
            self.manager.get_screen("screen3").list = list(self.liste)
            self.manager.current = "screen3"
            ##print(self.list)
    
        def switch2(self,*args):
            pass
            print(self.liste)
    
        def switch3(self,*args):
            self.liste = [8,9,10]
            print(self.liste)
      
    
    
    class Screen3(Screen):
        
        def __init__(self, liste, **kwargs):        
            self.liste = liste
            def myList(self):
                pass
                ##print(self.list)
    
    
            super(Screen3,self).__init__(**kwargs)
            Layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(Layout1)
            Layout1.switch_button = Button(text="ECRAN 3 : goto 1")
            Layout1.switch_button.bind(on_release=self.switch)
            Layout1.add_widget(Layout1.switch_button)
            Layout1.switch2_button = Button(text="Print List")
            Layout1.switch2_button.bind(on_release=self.switch2)
            Layout1.add_widget(Layout1.switch2_button)
            
        def switch(self,*args):
            self.manager.get_screen("screen1").list = list(self.liste)        
            self.manager.current = "screen1"
    
        def switch2(self,*args):
            pass
            print(self.liste)        
    
    class MainApp(App):
    
        def build(self):
    
            liste = [1, 2, 3]
            sc1 = Screen1(liste, name="screen1")
            sc2 = Screen2(liste, name="screen2")        
            sc3 = Screen3(liste, name="screen3")
    
            self.sm = ScreenManager()
    
            self.sm.add_widget(sc1)
            self.sm.add_widget(sc2)
            self.sm.add_widget(sc3)
    
            return self.sm
    
    
    MainApp().run()

  8. #8
    Modérateur

    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2008
    Messages
    14 468
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 14 468
    Points : 24 478
    Points
    24 478
    Par défaut
    Citation Envoyé par Arsene12 Voir le message
    Mais lorsque je passe de l'écran 1 à l'écran 2 en modifiant la liste, je récupère la liste initiale alors que je veux récupérer la liste modifiée.
    Ah ben oui... cependant dans votre premier post vous saviez apparemment le faire.
    Difficile de ne pas penser que vous ne comprenez pas trop les lignes de codes que vous écrivez et que vous n'avez pas pris le temps d'assimiler des notions de bases du langage auxquelles se confrontent tous les débutants: portée des variables, objets mutables ou non,...
    Mais vous n'êtes pas en train de batailler pour comprendre une de ces notions de base en essayant de faire un exercice...

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

  9. #9
    Membre actif
    Profil pro
    Inscrit en
    février 2003
    Messages
    896
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : février 2003
    Messages : 896
    Points : 267
    Points
    267
    Par défaut
    Récupérer des paramètres est quelque chose de basique et je comprends pas pourquoi avec screenmanager on puisse pas y arriver simplement. J'ai une liste à l'écran 1 que je modifie lorsque je passe à l'écran 2. Je voudrai qu'un bouton de l'écran 2 affiche cette liste. En l'occurence, mon bouton devrait afficher [4,5,6] et non [1,2,3]

    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
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    from kivy.app import App
    from kivy.uix.screenmanager import ScreenManager, Screen
    from kivy.uix.gridlayout import GridLayout
    from kivy.uix.button import Button
    liste = [1,2,3]
    myBtn=["0"]
    class Screen1(Screen):
    
        
        def __init__(self, liste, **kwargs):
            self.list=liste
            super(Screen1,self).__init__(**kwargs)
            print(self.list)
            self.switch_button = Button(text="ECRAN 1 : goto 2")
            self.switch_button.bind(on_release=self.switch)
            self.add_widget(self.switch_button)
     
        def switch(self,*args):
            self.list = [4,5,6]
            self.manager.get_screen("screen2").list = list(self.list)
            self.manager.current = "screen2"
     
        def on_enter(self):
            print ("écran 1 : "+ str(self.list))
            #print (self.list)
     
    class Screen2(Screen):
     
        def __init__(self,liste, **kwargs):
    
            print ("C Super : "+ str(liste))
           
            super(Screen2,self).__init__(**kwargs)
            
            Layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(Layout1)
            Layout1.switch_button = Button(text="ECRAN 2 : goto 3")
            Layout1.switch_button.bind(on_release=self.switch)
            Layout1.add_widget(Layout1.switch_button)
            Layout1.switch2_button = Button(text="Print List")
            Layout1.switch2_button.bind(on_release=self.switch2)
            Layout1.add_widget(Layout1.switch2_button)
            Layout1.switch3_button = Button(text="Modifier List")
            Layout1.switch3_button.bind(on_release=self.switch3)
            Layout1.add_widget(Layout1.switch3_button)
    
            btn2 = Button(text=str(liste))
            myBtn.append(btn2)
            Layout1.add_widget(btn2) 
    
    
            print ("Super22222 : "+ str(liste))
     
        def switch(self,*args):
            self.manager.get_screen("screen3").list = list(self.list)
            self.manager.current = "screen3"
            print(self.list)
     
        def switch2(self,*args):
            print(self.list)
            print(myBtn[0])
     
        def switch3(self,*args):
            self.list = [8,9,10]
            print(self.list)
     
        def on_enter(self):
            print ("écran 2 : "+ str(self.list))
            #print (self.list)
     
        print(myBtn[0])
        myBtn[0]=str(liste)
     
     
    class Screen3(Screen):
     
        def __init__(self,**kwargs):        
     
            def myList(self):
                pass
                #print(self.list)
     
     
            super(Screen3,self).__init__(**kwargs)
            Layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(Layout1)
            Layout1.switch_button = Button(text="ECRAN 3 : goto 1")
            Layout1.switch_button.bind(on_release=self.switch)
            Layout1.add_widget(Layout1.switch_button)
            Layout1.switch2_button = Button(text="Print List")
            Layout1.switch2_button.bind(on_release=self.switch2)
            Layout1.add_widget(Layout1.switch2_button)
     
        def switch(self,*args):
            self.manager.get_screen("screen1").list = list(self.list)        
            self.manager.current = "screen1"
     
        def switch2(self,*args):
            print(self.list)        
     
        def on_enter(self):                         
            print ("écran 3 : "+ str(self.list))   
     
     
    class MainApp(App):
     
        def build(self):
    
            sc1 = Screen1(liste, name="screen1")
            sc2 = Screen2(liste, name="screen2")        
            sc3 = Screen3(name="screen3")
     
            self.sm = ScreenManager()
     
            self.sm.add_widget(sc1)
            self.sm.add_widget(sc2)
            self.sm.add_widget(sc3)
     
            return self.sm
     
     
    MainApp().run()




    Voici comment je programme sans ScreenManager, ça fonctionne très bien.

    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
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    import kivy
    from kivy.app import App
    from kivy.uix.gridlayout import GridLayout
    from kivy.uix.button import Button
    from kivy.uix.label import Label
     
    myBtn=[]
     
    class Grids(GridLayout):
        def __init__(self):
     
            monText=["Thé"]
            monText2=["Sucré"]        
     
            def do_action1(self):
     
                if myBtn[0].text=="Café" :
                        myBtn[0].text="Thé"
                        monText[:]=[]
                        monText.append("Thé")
                        print("Thea : "+str(monText[0]))
                else :
                        myBtn[0].text="Café"
                        monText[:]=[]
                        monText.append("Café")
                        print("Coffee : "+str(monText[0]))
            pass
     
            def do_action2(self):
     
                if myBtn[1].text=="Sucré" :
                        myBtn[1].text="Non sucré"
                        monText2[:]=[]
                        monText2.append("Non sucré")
                else :
                        myBtn[1].text="Sucré"
                        monText2[:]=[]
                        monText2.append("Sucré")
            pass
     
     
            def screen1(self):
                    Layout1=self.parent
                    self.parent.clear_widgets()
                    play = Label(text = "Café")
                    Layout1.add_widget(play)
                    myBtn[:]=[]
                    myBtn.append(play)
                    changing = Layout1.add_widget(Button(text = "Changez de boisson", on_press=do_action1))
                    clickBtn = Button(text = "OK", on_press=screen2)
                    Layout1.add_widget(clickBtn)        
     
            def screen2(self):
                print(self)
                myLayout=self.parent
                self.parent.clear_widgets()
                play = Button(text = monText[0])            
                myLayout.add_widget(play)
                myBtn[:]=[]
                myBtn.append(play)
                play2 = Button(text = monText2[0])            
                myLayout.add_widget(play2)
                myBtn.append(play2)
                myLayout.add_widget(Button(text = "Sucre / Sans sucre", on_press=do_action2))
                clickBtn = Button(text = "OK", on_press=screen3)
                myLayout.add_widget(clickBtn)
     
            pass
     
            def screen3(self):
                print(self)
                myLayout=self.parent
                self.parent.clear_widgets()
                myLayout.add_widget(Button(text = str(monText[0]) + " " + str(monText2[0])))
                clickBtn = Button(text = "OK", on_press=screen1)
                myLayout.add_widget(clickBtn)
     
            pass 
     
     
     
            GridLayout.__init__(self, cols=2, rows = 2)
            Layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(Layout1)
            play = Label(text = "Café")
            Layout1.add_widget(play)
            myBtn.append(play)
            changing = Layout1.add_widget(Button(text = "Changez de boisson", on_press=do_action1))
            clickBtn = Button(text = "OK", on_press=screen2)
            Layout1.add_widget(clickBtn)
     
     
    class Example(App):
        def build(self):
            return Grids()
     
    if __name__ == '__main__':
        x = Example();
        x.run();

  10. #10
    Membre éprouvé

    Homme Profil pro
    ValueError
    Inscrit en
    avril 2016
    Messages
    689
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : ValueError

    Informations forums :
    Inscription : avril 2016
    Messages : 689
    Points : 1 018
    Points
    1 018
    Billets dans le blog
    1
    Par défaut
    Salut.

    Citation Envoyé par Arsene12 Voir le message
    Récupérer des paramètres est quelque chose de basique et je comprends pas pourquoi avec screenmanager on puisse pas y arriver simplement.
    J'extrapole avec ce qui semble te poser problème, n'étant pas sûr d'avoir tout saisi :

    Je pense que tu n'as pas compris comment ça fonctionne, le manager ne recrée pas tes objets screen* à chaque changement d'écran (puisque c'est toi qui les instancies), tout est gardé en mémoire, donc si quelque chose doit changer sur l'un des écrans, c'est à toi de le mettre à jour.


    Exemple simple (et crade), mais pas sûr que ce soit la meilleure méthode ne connaissant pas vraiment kivy et les fonctionnalités proposées.

    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
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    from kivy.app import App
    from kivy.uix.screenmanager import ScreenManager, Screen
    from kivy.uix.gridlayout import GridLayout
    from kivy.uix.button import Button
     
    class CustomScreen(Screen) :
        def switch(self, screen_name) :
            self.manager.current = screen_name
     
        def on_enter(self) :
            print('Écran :', self.manager.current)
            self.show_list()
            print('\n')
     
        def show_list(self) :
            print('Liste :', self.liste)
     
     
    class Screen1(CustomScreen) :
        def __init__(self, **kw) :
            super().__init__(**kw)
            self.switch_button = Button(text="ECRAN 1 : goto 2")
            self.switch_button.bind(on_release=lambda e: self.switch('screen2'))
            self.add_widget(self.switch_button)
     
     
    class Screen2(CustomScreen):    
     
        def __init__(self, **kw):
            super().__init__(**kw)
     
            layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(layout1)
            switch_button = Button(text="ECRAN 2 : goto 3")
            switch_button.bind(on_release=lambda e: self.switch('screen3'))
            layout1.add_widget(switch_button)
            print_button = Button(text="Print List")
            print_button.bind(on_release=lambda e: self.show_list())
            layout1.add_widget(print_button)
            mutate_button = Button(text="Modifier List")
            mutate_button.bind(on_release=lambda e: self.mutate_list())
            layout1.add_widget(mutate_button)
     
        def mutate_list(self) :
            self.liste[0:3] = (i+1 for i in self.liste[0:3])
     
     
    class Screen3(CustomScreen) :
        def __init__(self, **kw) :        
            super().__init__(**kw)
            layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(layout1)
            switch_button = Button(text="ECRAN 3 : goto 1")
            switch_button.bind(on_release=lambda e: self.switch('screen1'))
            layout1.add_widget(switch_button)
            print_button = Button(text="Print List")
            print_button.bind(on_release=lambda e: self.show_list())
            layout1.add_widget(print_button)
     
            self.buttons = []
            for n in self.liste :
                print(n)
                bt =  Button(text=str(n))
                self.buttons.append(bt)
                layout1.add_widget(bt)
     
        def updateButtons(self) :
            for i, bt in enumerate(self.buttons):
                bt.text = str(self.liste[i])
     
        def on_enter(self) :
            self.updateButtons()
            super().on_enter()
     
     
    class MainApp(App):
     
        def build(self):
            CustomScreen.liste = [1, 2, 3]
            screens = (
                Screen1(name="screen1"),
                Screen2(name="screen2"),   
                Screen3(name="screen3"),
            )
            sm = ScreenManager()
            for s in screens :
                sm.add_widget(s)
            sm.current = 'screen1'
            return sm
     
    MainApp().run()
    Mais pour moi, vu les impacts que peut causer la liste sur les différents écrans, ta liste devrait être un objet un peu plus complexe, auquel on pourrait inscrire des callbacks à appeler à chaque changements de ses valeurs.
    Le temps ronge l'amour comme l'acide.

  11. #11
    Modérateur

    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2008
    Messages
    14 468
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 14 468
    Points : 24 478
    Points
    24 478
    Par défaut
    Salut,

    Citation Envoyé par Arsene12 Voir le message
    Récupérer des paramètres est quelque chose de basique et je comprends pas pourquoi avec screenmanager on puisse pas y arriver simplement.
    Commencez par créer une classe à vous, deux instances qui partagent une liste, des méthodes qui modifient cette liste (partagée) et une méthode qui l'affiche. Si vous y arrivez, vous aurez fait un grand pas dans la compréhension du problème et sur comment le résoudre.

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

  12. #12
    Membre actif
    Profil pro
    Inscrit en
    février 2003
    Messages
    896
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : février 2003
    Messages : 896
    Points : 267
    Points
    267
    Par défaut
    Merci beaucoup pour toutes vos explications. Je commence à mieux comprendre et vous m'avez permis de trouver la solution. Elle repose sur la fonction on_enter(self). La réponse m'était donnée par Bistouille à 14h24 mais je l'avais pas vu, j'avais lu que la réponse suivante. Je me suis donc servi de la fonction def on_enter(self): pour modifier ce que j'ai initialisé avec def __init__(self, **kwargs): Dans mon code ci-dessous, je n'ai pas créé de liste commune et j'ai utilisé la méthode
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    self.manager.get_screen("screen X").list = list(self.list)
    pour transférer la liste à l'écran suivant.

    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
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    from kivy.app import App
    from kivy.uix.screenmanager import ScreenManager, Screen
    from kivy.uix.gridlayout import GridLayout
    from kivy.uix.button import Button
    
    
    myBtn=[]
    
     
    class Screen1(Screen):
    
        def __init__(self, **kwargs):
    
            super(Screen1,self).__init__(**kwargs)
            self.switch_button = Button(text="ECRAN 1 : goto 2")
            self.switch_button.bind(on_release=self.switch)
            self.add_widget(self.switch_button)
     
        def switch(self,*args):        
            self.list = [4,5,6]   # je modifie ma liste
            self.manager.get_screen("screen2").list = list(self.list)  # je la tranfère à l'écran 2
            self.manager.current = "screen2" # je vais à l'écran 2
    
     
        def on_enter(self):
            pass
            #print ("écran 1 : "+ str(maList))
            #print (self.list)
     
    class Screen2(Screen):    
     
        def __init__(self, **kwargs):
    
            super(Screen2, self).__init__(**kwargs)
     
            Layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(Layout1)
            Layout1.switch_button = Button(text="ECRAN 2 : goto 3")
            Layout1.switch_button.bind(on_release=self.switch)
            Layout1.add_widget(Layout1.switch_button)
            Layout1.switch2_button = Button(text="Print List")
            Layout1.switch2_button.bind(on_release=self.switch2)
            Layout1.add_widget(Layout1.switch2_button)
            Layout1.switch3_button = Button(text="Modifier Liste")
            Layout1.switch3_button.bind(on_release=self.switch3)
            Layout1.add_widget(Layout1.switch3_button)
            Layout1.switch4_button = Button(text="Liste")
            Layout1.add_widget(Layout1.switch4_button)
            myBtn.append(Layout1.switch4_button)
            
     
        def switch(self,*args):
            self.manager.get_screen("screen3").list = list(self.list)
            self.manager.current = "screen3"
            ##print(self.list)
     
        def switch2(self,*args):
            pass
            print(self.list)
     
        def switch3(self,*args):
            self.list = [8,9,10]
            myBtn[0].text=str(self.list) # je modifie le texte du bouton avec ma liste
            print(self.list)
     
        def on_enter(self):
            pass
            print ("écran 2 : "+ str(self.list))
            print (myBtn)
            myBtn[0].text=str(self.list) # je modifie le texte du bouton avec ma liste
     
    class Screen3(Screen):
     
        def __init__(self, **kwargs):        
    
            def myList(self):
                pass
                ##print(self.list)
     
            super(Screen3,self).__init__(**kwargs)
            Layout1 = GridLayout(cols=1, row_force_default=True, row_default_height=40)
            self.add_widget(Layout1)
            Layout1.switch_button = Button(text="ECRAN 3 : goto 1")
            Layout1.switch_button.bind(on_release=self.switch)
            Layout1.add_widget(Layout1.switch_button)
            Layout1.switch2_button = Button(text="Print List")
            Layout1.switch2_button.bind(on_release=self.switch2)
            Layout1.add_widget(Layout1.switch2_button)
     
        def switch(self,*args):
            self.manager.get_screen("screen1").list = list(self.list)        
            self.manager.current = "screen1"
     
        def switch2(self,*args):
            pass
            print(self.list)        
     
        def on_enter(self):
            pass
            print ("écran 3 : "+ str(self.list))   
     
    class MainApp(App):
     
        def build(self):
            
            sc1 = Screen1(name="screen1")
            sc2 = Screen2(name="screen2")        
            sc3 = Screen3(name="screen3")
     
            self.sm = ScreenManager()
     
            self.sm.add_widget(sc1)
            self.sm.add_widget(sc2)
            self.sm.add_widget(sc3)
     
            return self.sm
     
    MainApp().run()

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

Discussions similaires

  1. liste déroulante avec données mysql
    Par fab44 dans le forum Balisage (X)HTML et validation W3C
    Réponses: 2
    Dernier message: 24/02/2005, 20h45
  2. liste deroulante avec plusieurs champs
    Par JulienT dans le forum Struts 1
    Réponses: 4
    Dernier message: 20/04/2004, 18h17
  3. liste déroulante avec session
    Par leeloo076 dans le forum ASP
    Réponses: 3
    Dernier message: 19/03/2004, 12h01
  4. [LG]Listes chainées avec pointeur
    Par PaowZ dans le forum Langage
    Réponses: 2
    Dernier message: 17/02/2004, 20h49

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