Commencer avec kivy

Touchez, attrapez et déplacez #

L’exemple suivant crée un canevas avec 2 points et 1 ligne entre les deux. Vous pourrez déplacer le point et la ligne autour.

from kivy.app import App
from kivy.graphics import Ellipse, Line
from kivy.uix.boxlayout import BoxLayout


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.add(self.canvas_nodes[0])
        self.canvas.add(self.canvas_nodes[1])
        self.define_edge()
        self.canvas.add(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 (value.pos[0] - self.nodesize[0]) <= touch.pos[0] <= (value.pos[0] + self.nodesize[0]):
                if (value.pos[1] - self.nodesize[1]) <= touch.pos[1] <= (value.pos[1] + self.nodesize[1]):
                    touch.grab(self)
                    self.grabbed = self.canvas_nodes[key]
                    return True

    def on_touch_move(self, touch):

        if touch.grab_current is self:
            self.grabbed.pos = [touch.pos[0] - self.nodesize[0] / 2, touch.pos[1] - self.nodesize[1] / 2]
            self.canvas.clear()
            self.canvas.add(self.canvas_nodes[0])
            self.canvas.add(self.canvas_nodes[1])
            self.define_edge()
            self.canvas.add(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()

Exemple de popup simple dans Kivy. #

Le code suivant illustre comment faire un popup simple avec Kivy.

from kivy.app import App
from kivy.uix.popup import Popup
from kivy.lang import Builder
from kivy.uix.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()
        pops.open()

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

SampleApp().run()

##Installation et configuration

Les fenêtres #

Il existe deux options pour installer Kivy :

Assurez-vous d’abord que les outils Python sont à jour.

python -m pip install --upgrade pip wheel setuptools

Installez ensuite les dépendances de base.

python -m pip install docutils pygments pypiwin32 kivy.deps.sdl2 kivy.deps.glew

Bien que Kivy ait déjà des fournisseurs pour l’audio et la vidéo, GStreamer est requis pour des choses plus avancées.

python -m pip install kivy.deps.gstreamer --extra-index-url https://kivy.org/downloads/packages/simple/

Pour simplifier, <python> dans le texte suivant signifie un chemin vers le répertoire avec le fichier python.exe.

1. Roue

   The wheel package provides compiled Kivy, but with removed cython source components, which means the core code can’t be recompiled using this way. Python code, however, is editable.

La version stable de Kivy est disponible sur pypi.

   python -m pip install kivy

The latest version from the official repository is available through nightly-built wheels available on google drive. Visit the link in [docs](https://kivy.org/docs/installation/installation-windows.html#nightly-wheel-installation) matching your python version. After a proper wheel is downloaded, rename it to match the formatting of this example and run the command.

   python -m pip install C:\Kivy-1.9.1.dev-cp27-none-win_amd64.whl

2. Source

Il y a plus de dépendances nécessaires pour installer Kivy à partir de la source que d’utiliser les roues, mais l’installation est plus flexible.

Créez un nouveau fichier dans <python>\Lib\distutils\distutils.cfg avec ces lignes pour vous assurer qu’un compilateur approprié sera utilisé pour le code source.

   [build]
   compiler = mingw32

Ensuite, le compilateur est nécessaire. Utilisez-en certains que vous avez déjà installés ou téléchargez mingwpy. Les fichiers importants tels que gcc.exe seront situés dans <python>\Scripts.

   python -m pip install -i https://pypi.anaconda.org/carlkl/simple mingwpy

N’oubliez pas de définir des variables d’environnement pour que Kivy sache quels fournisseurs il doit utiliser.

   set USE_SDL2=1
   set USE_GSTREAMER=1

Installez maintenant les dépendances supplémentaires nécessaires à la compilation.

   python -m pip install cython kivy.deps.glew_dev kivy.deps.sdl2_dev
   python -m pip install kivy.deps.gstreamer_dev --extra-index-url https://kivy.org/downloads/packages/simple/

Vérifiez la section “Chemins” pour vous assurer que tout est correctement défini et installez Kivy. Choisissez l’une de ces options :

   python -m pip install C:\master.zip
   python -m pip install https://github.com/kivy/kivy/archive/master.zip

Chemins #

Kivy a besoin d’un accès aux binaires de certaines dépendances. Cela signifie que les dossiers corrects doivent se trouver dans la variable PATH de l’environnement.

set PATH=<python>\Tools;<python>\Scripts;<python>\share\sdl2\bin;%PATH%

De cette façon Python IDLE IDE peut être inclus dans le chemin avec <python>\Lib\idlelib;. Ensuite, écrivez “idle” dans la console et IDLE sera prêt à utiliser Kivy.

Simplifiez-le #

Pour éviter la définition répétitive des variables d’environnement, définissez chaque chemin nécessaire [de cette façon] (http://superuser.com/questions/737542) ou créez un fichier batch (.bat) avec ces lignes placées dans <python> :

set PATH=%~dp0;%~dp0Tools;%~dp0Scripts;%~dp0share\sdl2\bin;%~dp0Lib\idlelib;%PATH%
cmd.exe

Pour exécuter le projet Kivy après l’installation, exécutez cmd.exe ou le fichier batch et utilisez python <filename>.py

installation sur Ubuntu

Pour installer kivy sur ubuntu avec l’exemple de kivy, ouvrez le terminal et exécutez la commande suivante

Ajoutez d’abord ppa

 sudo add-apt-repository ppa:kivy-team/kivy

Pour installer kivy

 sudo apt-get install python-kivy

Pour installer des exemples de kivy

 sudo apt-get install python-kivy-example

Bonjour monde désespéré. #

Le code suivant illustre comment créer une application “hello world” dans kivy. Pour exécuter cette application dans ios et android, enregistrez-la sous main.py et utilisez buildozer.

from kivy.app import App
from kivy.uix.label import Label
from kivy.lang import Builder

Builder.load_string('''
<SimpleLabel>:
    text: 'Hello World'
''')


class SimpleLabel(Label):
    pass


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

if __name__ == "__main__":
    SampleApp().run()

RecycleView #

from kivy.app import App
from kivy.lang import Builder
from kivy.uix.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)
        root.data = [item for item in items]
        return root


Test().run()

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

La plupart des applications kivy commencent par cette structure :

from kivy.app import App

class TutorialApp(App):
    def build(self):
        return 
TutorialApp().run()

Il y a plusieurs façons de partir d’ici :

Tous les codes ci-dessous (sauf les exemples 1 et 3) ont le même widget et des fonctionnalités similaires, mais montrent une manière différente de créer l’application.

Exemple 1 : retour d’un seul widget (application Hello World simple)

from kivy.app import App
from kivy.uix.button import Button
class TutorialApp(App):
    def build(self):
        return Button(text="Hello World!")
TutorialApp().run()

Exemple 2 : renvoi de plusieurs widgets + le bouton imprime le texte du libellé

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.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)
        mybutton.bind(on_press= lambda a:print(mylabel.text))
        mylayout.add_widget(mybutton)
        return mylayout
TutorialApp().run()

Exemple 3 : utilisation d’une classe (widget unique) + le bouton imprime “Mon bouton”

from kivy.app import App
from kivy.uix.button import Button

class Mybutton(Button):
    text="Click me!"
    on_press =lambda a : print("My Button")    
    
class TutorialApp(App):
    def build(self):
        return Mybutton()
TutorialApp().run()

**Exemple 4 : c’est la même chose que ex. 2 mais il montre comment utiliser une classe **

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.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!")
        mybutton.bind(on_press= lambda a:print(mylabel.text))
        self.add_widget(mybutton)
        
class TutorialApp(App):
    def build(self):
        return MyLayout()
TutorialApp().run()

Avec le langage .kv #

Exemple 5 : le même mais montrant comment utiliser le langage kv dans python

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout 
# BoxLayout: it's in the python part, so you need to import it

from kivy.lang 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(mylabel.text)
""")
class MyLayout(BoxLayout):
    pass
class TutorialApp(App):
    def build(self):
        return MyLayout()
TutorialApp().run()

**Exemple 6 : idem avec la partie kv dans un fichier Tutorial.kv **

Dans .py :

from kivy.app import App
from kivy.uix.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()

Dans Tutoriel.kv :

<MyLayout> # no need to import stuff in kv!
    orientation:"vertical"
    Label:
        id:mylabel
        text:"My App"
    Button:
        text: "Click me!"
        on_press: print(mylabel.text)

**Exemple 7 : lien vers un fichier kv spécifique + un def en python recevant le label.text **

Dans .py :

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout

class MyLayout(BoxLayout):
    def printMe(self_xx, yy):
        print(yy)
class TutorialApp(App): 
    def build(self):
        self.load_kv('myapp.kv')
        return MyLayout()
TutorialApp().run()

Dans myapp.kv : orientation:“vertical” Label: id:mylabel text:“My App” Button: text: “Click me!” on_press: root.printMe(mylabel.text)

Exemple 8 : le bouton imprime le texte de l’étiquette (avec un def en python utilisant ids(les “ID”) )

Remarquerez que:

• self_xx de l’exemple 7 est remplacé par self

Dans .py :

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout

class MyLayout(BoxLayout):
    def printMe(self):
        print(self.ids.mylabel.text)
class TutorialApp(App):
    def build(self):
        self.load_kv('myapp.kv')
        return MyLayout()
TutorialApp().run()

Dans myapp.kv :

<MyLayout>
    orientation:"vertical"
    Label:
        id:mylabel
        text:"My App"
    Button:
        text: "Click me!"
        on_press: root.printMe()

Exemple 9 : le bouton imprime le texte de l’étiquette (avec un def en python utilisant StringProperty)

Dans .py :

from kivy.app import App
from kivy.uix.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()

Dans Tutoriel.kv :

<MyLayout>
    orientation:"vertical"
    Label:
        id:mylabel
        text:root.stringProperty_mylabel
    Button:
        text: "Click me!"
        on_press: root.printMe()

Exemple 10 : le bouton imprime le texte de l’étiquette (avec un def en python utilisant ObjectProperty)

Dans .py :

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.properties import ObjectProperty
class MyLayout(BoxLayout):
    objectProperty_mylabel= ObjectProperty(None)
    def printMe(self):
        print(self.objectProperty_mylabel.text)

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

Dans Tutoriel.kv :

<MyLayout>
    orientation:"vertical"
    objectProperty_mylabel:mylabel
    Label:
        id:mylabel
        text:"My App"
    Button:
        text: "Click me!"
        on_press: root.printMe()