Tutoriel pour débuter avec le Framework Python Kivy

Bonjour tout le monde à kivy.

6

Exemple simple de popup dans Kivy.

7

RecycleView

7

Différentes façons d'exécuter une application simple et d'interagir avec des widgets

8

Avec le langage .kv

10

Chapitre 2: Propriété

14

Examples

14

Différence entre les propriétés et la liaison.

14

Chapitre 3: Utiliser le gestionnaire d'écran

17

Remarques

17

Importations circulaires

17

Examples

17

Utilisation simple du gestionnaire d'écran

17

Gestionnaire d'écran

19

Crédits

21

  class CustomLayout(BoxLayout):      def __init__(self, **kwargs):

        super(CustomLayout, self).__init__(**kwargs)

self.canvas_edge = {}         self.canvas_nodes = {}         self.nodesize = [25, 25]

        self.grabbed = {}

#declare a canvas         with self.canvas.after:

            pass

self.define_nodes()         (self.canvas_nodes[0]) (self.canvas_nodes[1])         self.define_edge() (self.canvas_edge)

      def define_nodes(self):

"""define all the node canvas elements as a list"""

self.canvas_nodes[0] = Ellipse(             size = self.nodesize, pos =  [100,100]

            )

self.canvas_nodes[1] = Ellipse(             size = self.nodesize, pos =  [200,200]

            )

     def define_edge(self):

"""define an edge canvas elements"""

        self.canvas_edge = Line(             points =  [                 self.canvas_nodes[0].pos[0] + self.nodesize[0] / 2,                 self.canvas_nodes[0].pos[1] + self.nodesize[1] / 2,                 self.canvas_nodes[1].pos[0] + self.nodesize[0] / 2,                 self.canvas_nodes[1].pos[1] + self.nodesize[1] / 2

],             joint = 'round',             cap = 'round',             width = 3

            )

      def on_touch_down(self, touch):          for key, value in self.canvas_nodes.items():

            if ([0] - self.nodesize[0]) <= [0] <= ([0] + self.nodesize[0]):

if ([1] - self.nodesize[1]) <= [1] <= ([1] + self.nodesize[1]):

(self)                     self.grabbed = self.canvas_nodes[key]                     return True      def on_touch_move(self, touch):          if touch.grab_current is self:

= [[0] - self.nodesize[0] / 2, [1] - self.nodesize[1] / 2]             self.canvas.clear() (self.canvas_nodes[0])             (self.canvas_nodes[1]) self.define_edge()             (self.canvas_edge) else:

# it's a normal touch             pass      def on_touch_up(self, touch):         if touch.grab_current is self:

# I receive my grabbed touch, I must ungrab it! touch.ungrab(self)         else:

# it's a normal touch             pass  class MainApp(App):      def build(self):         root = CustomLayout()         return root  if __name__ == '__main__':

    MainApp().run()

from import App from .label import Label from import Builder

Builder.load_string('''

<SimpleLabel>:

    text: 'Hello World'

''')

  class SimpleLabel(Label):

    pass

  class SampleApp(App):     def build(self):

return SimpleLabel()  if __name__ == "__main__":

from import App from .popup import Popup from import Builder from .button import Button

Builder.load_string('''

<SimpleButton>:

    on_press: self.fire_popup()

<SimplePopup>:

id:pop     size_hint: .4, .4     auto_dismiss: False     title: 'Hello world!!'

Button:         text: 'Click here to dismiss'         on_press: pop.dismiss()

''')

  class SimplePopup(Popup):

    pass  class SimpleButton(Button):     text = "Fire Popup !"     def fire_popup(self):         pops=SimplePopup()         ()  class SampleApp(App):     def build(self):

        return SimpleButton()

SampleApp().run()

from import App from import Builder from .button import Button

  items = [

    {"color":(1, 1, 1, 1), "font_size": "20sp", "text": "white",     "input_data":

["some","random","data"]},

{"color":(.5,1, 1, 1), "font_size": "30sp", "text": "lightblue", "input_data": [1,6,3]},

    {"color":(.5,.5,1, 1), "font_size": "40sp", "text": "blue", "input_data": [64,16,9]},     {"color":(.5,.5,.5,1), "font_size": "70sp", "text": "gray", "input_data":

[8766,13,6]},

    {"color":(1,.5,.5, 1), "font_size": "60sp", "text": "orange", "input_data": [9,4,6]},     {"color":(1, 1,.5, 1), "font_size": "50sp", "text": "yellow", "input_data":

[852,958,123]}

]

  class MyButton(Button):      def print_data(self,data):

        print(data)

KV = '''

<MyButton>: on_release:

root.print_data(self.input_data) 

RecycleView: data: []     viewclass: 'MyButton'

RecycleBoxLayout:         default_size_hint: 1, None         orientation: 'vertical'

'''

  class Test(App):     def build(self):

root = Builder.load_string(KV)         = [item for item in items]         return root

Test().run()

from import App from .boxlayout import BoxLayout from .label import Label from .button import Button  class TutorialApp(App):     def build(self):

mylayout = BoxLayout(orientation="vertical")         mylabel = Label(text= "My App")         mybutton =Button(text="Click me!")         mylayout.add_widget(mylabel) (on_press= lambda a:print()) mylayout.add_widget(mybutton)         return mylayout

TutorialApp().run()

from import App from .boxlayout import BoxLayout from .label import Label from .button import Button  class MyLayout(BoxLayout):     #You don't need to understand these 2 lines to make it work!     def __init__(self, **kwargs):

        super(MyLayout, self).__init__(**kwargs)

self.orientation="vertical"         mylabel = Label(text= "My App")         self.add_widget(mylabel)         mybutton =Button(text="Click me!")         (on_press= lambda a:print())         self.add_widget(mybutton)  class TutorialApp(App): def build(self):

from import App from .boxlayout import BoxLayout

# BoxLayout: it's in the python part, so you need to import it

from import Builder

Builder.load_string("""

<MyLayout>

orientation:"vertical"

    Label: # it's in the kv part, so no need to import it         id:mylabel text:"My App"

Button:         text: "Click me!"         on_press: print() """) class MyLayout(BoxLayout):

    pass class TutorialApp(App):     def build(self):         return MyLayout()

TutorialApp().run()

from import App from .boxlayout import BoxLayout  class MyLayout(BoxLayout):

    pass class TutorialApp(App): #the kv file name will be Tutorial (name is before the "App")     def build(self):         return MyLayout()

TutorialApp().run()

<MyLayout> # no need to import stuff in kv!     orientation:"vertical"

    Label:

id:mylabel         text:"My App"

Button:         text: "Click me!"         on_press: print()

from import App from .boxlayout import BoxLayout  class MyLayout(BoxLayout):     def printMe(self_xx, yy):

print(yy) class TutorialApp(App):     def build(self):

self.load_kv('')         return MyLayout()

TutorialApp().run()

from import App from .boxlayout import BoxLayout  class MyLayout(BoxLayout):     def printMe(self):

print() class TutorialApp(App):     def build(self):

self.load_kv('')         return MyLayout()

TutorialApp().run()

<MyLayout>

orientation:"vertical"

    Label:

id:mylabel         text:"My App"

Button:         text: "Click me!"         on_press: root.printMe()

from import App from .boxlayout import BoxLayout from kivy.properties import StringProperty class MyLayout(BoxLayout):

    stringProperty_mylabel= StringProperty("My App")     def printMe(self):

print(self.stringProperty_mylabel)  class TutorialApp(App):     def build(self):         return MyLayout()

TutorialApp().run()

<MyLayout>

orientation:"vertical"

    Label:

id:mylabel         text:root.stringProperty_mylabel

Button:         text: "Click me!"         on_press: root.printMe()

from import App from .boxlayout import BoxLayout from kivy.properties import ObjectProperty class MyLayout(BoxLayout):

    objectProperty_mylabel= ObjectProperty(None)     def printMe(self):

print()  class TutorialApp(App):     def build(self):         return MyLayout()

TutorialApp().run()

<MyLayout>

orientation:"vertical"     objectProperty_mylabel:mylabel

    Label:

id:mylabel         text:"My App"

Button:         text: "Click me!"         on_press: root.printMe()

from import App from .boxlayout import BoxLayout from import Builder from kivy.properties import StringProperty from kivy.properties import ObjectProperty from .textinput import TextInput from kivy.event import EventDispatcher

Builder.load_string("""

<CustLab1@Label> size_hint:0.3,1

<CustLab2@Label> text: "Result"     size_hint: 0.5,1 <CustButton@Button> text: "+1"     size_hint: 0.1,1

<CustTextInput@TextInput>:

multiline: False     size_hint:0.1,1 

<Tuto_Property>: orientation: "vertical"     padding:10,10     spacing: 10

Label:         text: "Press the 3 button (+1) several times and then modify the number in the

first counter (with StringProperty but no binding) doesn't take into account the change that happened in the app, but the second one does.String Property makes it easy to pass the update from the python side to the user interface, binding pass the changes that happened on the user interface to the python side. "         text_size:          padding: 20,20 Property_no_Binding:

    Property_with_Binding:

    Simple:

<Property_no_Binding>:

spacing: 10     label_ObjectProperty: result

    CustLab1:

text: "With Property but no Binding"     CustButton:

        on_press: root.counter_textInput_StringProperty()

    CustTextInput:

id:textinput_id         text: root.textInput_StringProperty

    CustLab2:

id: result 

<Property_with_Binding>:

spacing: 10     label_ObjectProperty: result

    CustLab1:

        text: "With Property and Binding"

CustButton:         on_press: root.counter_textInput_StringProperty()

    CustTextInput:

id:textinput_id         text: root.textInput_StringProperty         on_text: root.textInput_StringProperty =    ## this is the binding

    CustLab2:

        id: result

<Simple> spacing: 10     CustLab1:

        text: "Without Property"

CustButton:         on_press: root.simple(textinput_id, result)

CustTextInput:         id:textinput_id         text: "0"

    CustLab2:

        id: result

""")

 class Property_no_Binding(BoxLayout):

textInput_StringProperty= StringProperty("0") label_ObjectProperty = ObjectProperty(None)     def counter_textInput_StringProperty(self):

= ("Before the counter was updated:\n\n :" + + "\n\n textInput_StringProperty:" + self.textInput_StringProperty) self.textInput_StringProperty =str(int(self.textInput_StringProperty)+1) class Property_with_Binding(BoxLayout):

textInput_StringProperty= StringProperty("0") label_ObjectProperty = ObjectProperty(None)     def counter_textInput_StringProperty(self):

= ("Before the counter was updated:\n\n :" + + "\n\n textInput_StringProperty:" + self.textInput_StringProperty) self.textInput_StringProperty =str(int(self.textInput_StringProperty)+1) pass  class Simple(BoxLayout):     def simple(self,textinput_id, result):

= ("Before the counter was updated:\n\nIn the TextInput:" + )         = str(int() + 1)

pass class Tuto_Property(BoxLayout):

     # def __init__(self, **kwargs):

        # super(All, self).__init__(**kwargs)

        # app=App.get_running_app()

        # (text=lambda *a: self.change(app))

        # print(self.parent)

     # def counter(self,app):

        # print("Stringproperty:",app.numbertext)

        # print("ObjectProperty:",)

        # print("text:",,"\n")         # app.numbertext=str(int(app.numbertext)+1)

     # def change(self, app):

        #      pass class MyApp(App):

numbertext = StringProperty("0")     def build(self):

        return Tuto_Property()

MyApp().run()

# A line used mostly as the first one, imports App class

# that is used to get a window and launch the application from import App

# Casual Kivy widgets that reside in from .label import Label from .button import Button from .boxlayout import BoxLayout from .screenmanager import ScreenManager, Screen from .screenmanager import SlideTransition

# Inherit Screen class and make it look like

# a simple page with navigation

 class CustomScreen(Screen):

    # It's necessary to initialize a widget the class inherits

    # from to access its methods such as 'add_widget' with 'super()'

     def __init__(self, **kwargs):

        # Py2/Py3 note: although in Py3 'super()' is simplified

        # it's a good practice to use Py2 syntax, so that the

        # code is compatibile in both versions         super(CustomScreen, self).__init__(**kwargs)

        # Put a layout in the Screen which will take

        # Screen's size and pos.

        # The 'orientation' represents a direction

        # in which the widgets are added into the         # BoxLayout - 'horizontal' is the default         layout = BoxLayout(orientation='vertical')

        # Add a Label with the name of Screen

        # and set its size to 50px

layout.add_widget(Label(, font_size=50))

        # Add another layout to handle the navigation

        # and set the height of navigation to 20%

        # of the CustomScreen

        navig = BoxLayout(size_hint_y=0.2)

        # Create buttons with a custom text         prev = Button(text='Previous')         next = Button(text='Next')

        # Bind to 'on_release' events of Buttons (on_release=self.switch_prev) (on_release=self.switch_next)

        # Add buttons to navigation

        # and the navigation to layout         navig.add_widget(prev)         navig.add_widget(next) layout.add_widget(navig)

        # And add the layout to the Screen         self.add_widget(layout)

    # *args is used to catch arguments that are returned

    # when 'on_release' event is dispatched

     def switch_prev(self, *args):

        # 'self.manager' holds a reference to ScreenManager object

        # and 'ScreenManager.current' is a name of a visible Screen

        # Methods 'ScreenManager.previous()' and '()'

        # return a string of a previous/next Screen's name self.manager.transition = SlideTransition(direction="right")         self.manager.current = self.manager.previous()      def switch_next(self, *args):

        self.manager.transition = SlideTransition(direction="right")         self.manager.current = ()

  class ScreenManagerApp(App):

    # 'build' is a method of App used in the framework it's

    # expected that the method returns an object of a Kivy widget

     def build(self):

        # Get an object of some widget that will be the core

        # of the application - in this case ScreenManager         root = ScreenManager()

        # Add 4 CustomScreens with name 'Screen <order>`         for x in range(4):

root.add_widget(CustomScreen(name='Screen %d' % x))

        # Return the object         return root

# This is only a protection, so that if the file # is imported it won't try to launch another App

 if __name__ == '__main__':

    # And run the App with its method 'run'

    ScreenManagerApp().run()

from import App from import Builder from .screenmanager import ScreenManager, Screen

# Create both screens. Please note the root.manager.current: this is how

# you can control the ScreenManager from kv. Each screen has by default a # property manager that gives you the instance of the ScreenManager used.

Builder.load_string(""" <MenuScreen>:

    BoxLayout:

Button:             text: 'First Button on Menu'             on_press: root.manager.current = 'settings'

        Button:

text: 'Second Button on Menu'  <SettingsScreen>:

    BoxLayout:

        Button:

text: 'First Button on Settings'             on_press: root.manager.current = 'menu'

Button:             text: 'Second Button on Settings'

""")

# Declare both screens class MenuScreen(Screen):

    pass class SettingsScreen(Screen):

    pass

# Create the screen manager sm = ScreenManager() sm.add_widget(MenuScreen(name='menu')) sm.add_widget(SettingsScreen(name='settings'))

S.

No

Chapitres

Contributeurs

1

Commencer avec kivy

Community, Daniel Engel, EL3PHANTEN, Enora, Fermi paradox, JinSnow, Kallz, KeyWeeUsr, phunsukwangdu, picibucor, user2314737, Will

2

Propriété

Enora, YOSHI

3

Utiliser le gestionnaire d'écran

KeyWeeUsr, M Ganesh, OllieNye, picibucor