# 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.define_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.define_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

<SimpleButton>:
on_press: self.fire_popup()
<SimplePopup>:
id:pop
size_hint: .4, .4
auto_dismiss: False
title: 'Hello world!!'
Button:
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
``````
1. 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
``````

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

<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.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!")
mybutton.bind(on_press= lambda a:print(mylabel.text))
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")
mybutton =Button(text="Click me!")
mybutton.bind(on_press= lambda a:print(mylabel.text))

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