kivy Tutoriel
Commencer avec kivy

Android Django Git iOS Java Language GNU/Linux matplotlib MySQL opencv Python Language
Recherche…


Remarques

Kivy est une bibliothèque Python open source pour le développement rapide d'interfaces utilisateur multi-plateformes. Les applications Kivy peuvent être développées pour Linux, Windows, OS X, Android et iOS en utilisant le même code.

Les graphiques sont rendus via OpenGL ES 2 plutôt que par des widgets natifs, conduisant à une apparence assez uniforme entre les systèmes d'exploitation.

Le développement d'interfaces dans Kivy implique éventuellement l'utilisation de kvlang, un petit langage qui prend en charge les expressions de type python et python interop. L'utilisation de kvlang peut considérablement simplifier le développement de l'interface utilisateur par rapport à l'utilisation exclusive de Python.

Kivy est libre d'utiliser (actuellement sous la licence MIT), et professionnellement soutenu.

Installation et configuration

les fenêtres

Il y a deux options pour installer Kivy:

Assurez-vous d'abord que les outils python sont à jour. 

python -m pip install --upgrade pip wheel setuptools

Ensuite, installez 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 nécessaire 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 d'accès au répertoire python.exe fichier python.exe .

  1. Roue

    Le paquet de roue fournit compilé Kivy, mais avec éliminé cython composants de source, ce qui signifie le code de base ne peut pas être recompiler en utilisant de cette façon. Le code Python est cependant modifiable.

    La version stable de Kivy est disponible sur pypi. 

    python -m pip install kivy

    La dernière version du référentiel officiel est disponible via des roues de nuit disponibles sur Google Drive. Visitez le lien dans docs correspondant à votre version de python. Après avoir téléchargé une roue appropriée, renommez-la pour correspondre à la mise en forme de cet exemple et exécutez la commande. 

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

  2. La source

    Il y a plus de dépendances requises pour installer Kivy depuis 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. Soit en utiliser certains déjà installés, soit télécharger 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 sont les fournisseurs à utiliser. 

    set USE_SDL2=1
set USE_GSTREAMER=1

    Maintenant, installez les dépendances supplémentaires requises pour 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 des Paths pour vous assurer que tout est configuré correctement 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

Les chemins

Kivy a besoin d'un accès aux binaires de certaines dépendances. Cela signifie que les bons dossiers doivent être sur la variable PATH 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.

Simplifier

Pour éviter les réglages répétitifs des variables d'environnement, définissez chaque chemin nécessaire de cette manière 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 de commandes et utilisez python <filename>.py

installation sur Ubuntu

Pour installer kivy sur Ubuntu avec exemple kivy ouvrir un terminal et exécuter la commande suivante

Ajouter 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

Toucher, saisir et déplacer

L'exemple suivant crée un canevas avec 2 points et 1 ligne. Vous pourrez déplacer le point et la ligne. 

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

Bonjour tout le monde à kivy.

Le code suivant illustre comment créer une application "hello world" dans kivy. Pour exécuter cette application sur ios et android, enregistrez-la sous le nom 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()

Exemple simple de popup dans Kivy.

Le code suivant illustre comment faire une simple popup 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()

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 d'aller 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 (simple Hello World App) 

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: retour de plusieurs widgets + le bouton imprime le texte de l'étiquette 

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 "My Button" 

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 qu'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: la même chose 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: le même 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 Tutorial.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" Etiquette: id: texte mylabel: "Mon application" bouton: texte: "Cliquez sur moi!" on_press: root.printMe (mylabel.text)

Exemple 8: le bouton imprime le texte de l'étiquette (avec un def en python en utilisant les 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 en 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 Tutorial.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 en 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 Tutorial.kv: 

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


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow