Discussion :

[Arsene12]

Bonjour,

j'utilise Kivy et je fais un return pour afficher un widget. Je voudrai pouvoir continuer l'exécution de mon code après le return, en prenant en compte la création du widget. Je voudrai notamment afficher sa largeur. Y'a t-il un moyen de résoudre ce problème. Avec tkinter, j'utilise pas return et je fais un update(), c'est plus simple. Pourriez-vous m'aider, 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
import kivy
#kivy.require('1.9.0')
 
from kivy.app import App
from kivy.lang import Builder
from kivy.uix.stacklayout import StackLayout
from kivy.uix.button import Button
 
kv = '''
<MyButton>:
    size_hint: None, None
    size: self.texture_size
'''
Builder.load_string(kv)
 
class MyButton(Button):
    pass
 
class myApp(App):
    def build(self):
        self.widget = StackLayout()
        btn = MyButton(text="very long Word")
        self.widget.add_widget(btn)
        return btn          
        myWidth=btn.width 
        print("ça marche!")  
        print(myWidth)               
 
myApp().run()

[wiztricks]

Salut,

Je voudrai pouvoir continuer l'exécution de mon code après le return

"return" termine la fonction: ce qui est après est juste ignoré.

Par contre un GUI est toujours organisé avec une mainloop qui dispatche les évènements aux différents callbacks et il sait ordonnancer l'appel d'une fonction/callback après un délai donné.

- W

[Arsene12]

Salut,
"return" termine la fonction: ce qui est après est juste ignoré.
Par contre un GUI est toujours organisé avec une mainloop qui dispatche les évènements aux différents callbacks et il sait ordonnancer l'appel d'une fonction/callback après un délai donné.
- W

Merci mais comment faire un callback en utilisant un délai avec Kivy. Sauriez-vous lancer l'animation au démarrage sur ce code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
'''
FBO Canvas
==========
 
This demonstrates a layout using an FBO (Frame Buffer Off-screen)
instead of a plain canvas. You should see a black canvas with a
button labelled 'FBO' in the bottom left corner. Clicking it
animates the button moving right to left.
'''
 
__all__ = ('FboFloatLayout', )
 
from kivy.graphics import Color, Rectangle, Canvas, ClearBuffers, ClearColor
from kivy.graphics.fbo import Fbo
from kivy.uix.floatlayout import FloatLayout
from kivy.properties import ObjectProperty, NumericProperty
from kivy.app import App
from kivy.core.window import Window
from kivy.animation import Animation
from kivy.factory import Factory
 
 
class FboFloatLayout(FloatLayout):
 
    texture = ObjectProperty(None, allownone=True)
 
    alpha = NumericProperty(1)
 
    def __init__(self, **kwargs):
        self.canvas = Canvas()
        with self.canvas:
            self.fbo = Fbo(size=self.size)
            self.fbo_color = Color(1, 1, 1, 1)
            self.fbo_rect = Rectangle()
 
        with self.fbo:
            ClearColor(0, 0, 0, 0)
            ClearBuffers()
 
        # wait that all the instructions are in the canvas to set texture
        self.texture = self.fbo.texture
        super(FboFloatLayout, self).__init__(**kwargs)
 
    def add_widget(self, *largs):
        # trick to attach graphics instruction to fbo instead of canvas
        canvas = self.canvas
        self.canvas = self.fbo
        ret = super(FboFloatLayout, self).add_widget(*largs)
        self.canvas = canvas
        return ret
 
    def remove_widget(self, *largs):
        canvas = self.canvas
        self.canvas = self.fbo
        super(FboFloatLayout, self).remove_widget(*largs)
        self.canvas = canvas
 
    def on_size(self, instance, value):
        self.fbo.size = value
        self.texture = self.fbo.texture
        self.fbo_rect.size = value
 
    def on_pos(self, instance, value):
        self.fbo_rect.pos = value
 
    def on_texture(self, instance, value):
        self.fbo_rect.texture = value
 
    def on_alpha(self, instance, value):
        self.fbo_color.rgba = (1, 1, 1, value)
 
 
class ScreenLayerApp(App):
    def build(self):
 
        f = FboFloatLayout()
        b = Factory.Button(text="FBO", size_hint=(None, None))
        f.add_widget(b)
 
        def anim_btn(*args):
            if b.pos[0] == 0:
                Animation(x=f.width - b.width).start(b)
            else:
                Animation(x=0).start(b)
        b.bind(on_press=anim_btn)
 
        return f
 
 
if __name__ == "__main__":
    ScreenLayerApp().run()

[Arsene12]

Il faut passer par la fonction __init que je maîtrise pas bien encore et faire un CallBack:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

def __init__(self, **kwargs)

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
from kivy.uix.stacklayout import StackLayout
from kivy.lang import Builder
from kivy.app import App
from kivy.uix.button import Button
from kivy.clock import Clock
 
kv = '''
<MyButton>:
    size_hint: None, None
    size: self.texture_size
'''
Builder.load_string(kv)
 
class MyButton(Button):
        pass
 
class DemoBox(StackLayout):
 
    def __init__(self, **kwargs):           
        super(DemoBox, self).__init__(**kwargs)
 
        def my_callback(dt):
           print("Longueur initiale du bouton"+str(btn.width))
           btn.width=180
 
        def myNexText(self):
           print("Longueur actuelle du bouton"+str(btn.width))
 
        btn = MyButton(text="very very long Word")
        btn.bind(on_press=myNexText)
 
        self.add_widget(btn)
        Clock.schedule_once(my_callback, 1)
 
class DemoApp(App):
    def build(self):
        return DemoBox()
 
if __name__ == "__main__":
    DemoApp().run()

[Arsene12]

Merci mais comment faire un callback en utilisant un délai avec Kivy. Sauriez-vous lancer l'animation au démarrage sur ce code

Voici le code qui lance l'animation au démarrage :

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
from kivy.uix.floatlayout import FloatLayout
from kivy.properties import ObjectProperty, NumericProperty
from kivy.app import App
from kivy.core.window import Window
from kivy.animation import Animation
from kivy.uix.button import Button
 
Window.size = (800, 200)
 
 
class FboFloatLayout(FloatLayout):
 
    texture = ObjectProperty(None, allownone=True) 
    alpha = NumericProperty(1)
 
    def __init__(self, **kwargs):
        super(FboFloatLayout, self).__init__(**kwargs)
        b = Button(text="My Text", size_hint=(None, None))      
        for but in [b]:
            self.add_widget(but)
            print(b.parent.width)
        def anim_btn(*args):
            if b.pos[0] == 0:
                Animation(x=Window.width - b.width).start(b)
            else:
                Animation(x=0).start(b)
        anim_btn()        
 
class ScreenLayerApp(App):
 
    def build(self):
        return FboFloatLayout()
 
 
if __name__ == "__main__":
    ScreenLayerApp().run()