[kivy] Liste réinitialisée avec ScreenManager

Version imprimable

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:

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()

17/01/2019, 08h33
VinsS

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.
17/01/2019, 11h37
bistouille

Salut.

Citation:

"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.

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:

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()

Salut.

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

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:

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.

18/01/2019, 13h49
wiztricks
Citation:

Envoyé par Arsene12

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:

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:

1 2 3 4 5 6 class Screen2(Screen): def __init__(self, liste, **kwargs): self.liste = liste super().__init__(**kwargs) ...
- W

Citation:

Envoyé par wiztricks

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:

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:

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()

19/01/2019, 08h51
wiztricks

Citation:

Envoyé par Arsene12

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

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:

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:

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();

Salut.

Citation:

Envoyé par Arsene12

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:

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.

19/01/2019, 17h08
wiztricks

Salut,

Citation:

Envoyé par Arsene12

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

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. 8O 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:

self.manager.get_screen("screen X").list = list(self.list)

pour transférer la liste à l'écran suivant.

Code:

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()