kivy Tutorial => Iniziare con kivy

Osservazioni

Kivy è una libreria Python open source per il rapido sviluppo di interfacce utente multipiattaforma. Le applicazioni Kivy possono essere sviluppate per Linux, Windows, OS X, Android e iOS utilizzando la stessa base di codice.

La grafica è resa tramite OpenGL ES 2 piuttosto che attraverso widget nativi, portando a un aspetto abbastanza uniforme tra i sistemi operativi.

Lo sviluppo di interfacce in Kivy implica opzionalmente l'uso di kvlang, un linguaggio piccolo che supporta espressioni simili a pitone e interponi python. L'uso di kvlang può semplificare drasticamente lo sviluppo dell'interfaccia utente rispetto all'uso esclusivo di Python.

Kivy è gratuito da usare (attualmente con licenza MIT) e supportato professionalmente.

Installazione e configurazione

finestre

Ci sono due opzioni su come installare Kivy:

Prima assicurati che gli strumenti Python siano aggiornati.

python -m pip install --upgrade pip wheel setuptools

Quindi installare le dipendenze di base.

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

Sebbene Kivy abbia già provider per audio e video, GStreamer è richiesto per cose più avanzate.

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

Per renderlo più semplice, <python> nel seguente testo indica un percorso verso la directory con il file python.exe .

Ruota
Il pacchetto wheel fornisce Kivy compilato, ma con componenti sorgente cython rimossi, il che significa che il codice core non può essere ricompilato in questo modo. Il codice Python, tuttavia, è modificabile.
La versione stabile di Kivy è disponibile su pypi.
```
python -m pip install kivy
```
L'ultima versione dal repository ufficiale è disponibile attraverso ruote notturne disponibili su google drive. Visita il link in documenti che corrispondono alla tua versione di Python. Una volta scaricata una ruota adeguata, rinominarla in modo che corrisponda alla formattazione di questo esempio ed eseguire il comando.
```
python -m pip install C:\Kivy-1.9.1.dev-cp27-none-win_amd64.whl
```
fonte
Ci sono più dipendenze necessarie per installare Kivy dal sorgente piuttosto che usare le ruote, ma l'installazione è più flessibile.
Crea un nuovo file in <python>\Lib\distutils\distutils.cfg con queste linee per assicurarti che venga usato un compilatore appropriato per il codice sorgente.
```
[build]
compiler = mingw32
```
Quindi è necessario il compilatore. Utilizza alcuni di quelli che hai già installato o scarica mingwpy . I file importanti come gcc.exe troveranno in <python>\Scripts .
```
python -m pip install -i https://pypi.anaconda.org/carlkl/simple mingwpy
```
Non dimenticare di impostare le variabili di ambiente per consentire a Kivy di sapere quali provider utilizzare.
```
set USE_SDL2=1
set USE_GSTREAMER=1
```
Ora installa le dipendenze aggiuntive richieste per la compilazione.
```
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/
```
Controlla la sezione Paths per assicurarti che tutto sia impostato correttamente e installa Kivy. Scegli una di queste opzioni:
```
python -m pip install C:\master.zip
python -m pip install https://github.com/kivy/kivy/archive/master.zip
```

percorsi

Kivy ha bisogno di un accesso ai binari da alcune dipendenze. Ciò significa che le cartelle corrette devono trovarsi nella variabile PATH dell'ambiente.

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

In questo modo è possibile includere Python IDLE IDE nel percorso con <python>\Lib\idlelib; . Quindi scrivi idle su console e IDLE sarà pronto per l'uso di Kivy.

Semplificalo

Per evitare l'impostazione ripetitiva delle variabili di ambiente, impostare ciascun percorso necessario in questo modo o creare un file batch ( .bat ) con queste righe posizionate in <python> :

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

Per eseguire il progetto Kivy dopo l'installazione, eseguire cmd.exe o il file batch e utilizzare python <filename>.py

installazione su Ubuntu

Per installare kivy su ubuntu con kivy esempio aprire il terminale ed eseguire il comando seguente

Per prima cosa aggiungi ppa

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

Per installare kivy

 sudo apt-get install python-kivy

Per installare esempi di kivy

 sudo apt-get install python-kivy-example

Tocca, afferra e muovi

L'esempio seguente crea una tela con 2 punti e 1 linea in mezzo. Sarai in grado di spostare il punto e la linea intorno.

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

Ciao mondo in kivy.

Il seguente codice illustra come realizzare l'app 'hello world' in kivy.Per eseguire questa app in ios ed android, salvala come main.py e usa 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()

Il seguente codice illustra come eseguire semplici popup con 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()

La maggior parte delle app Kivy inizia con questa struttura:

from kivy.app import App

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

C'è un modo diverso per andare da qui:

Tutti i codici di seguito (ad eccezione degli esempi 1 e 3) hanno lo stesso widget e caratteristiche simili, ma mostrano un modo diverso di costruire l'app.

Esempio 1: restituzione di un singolo widget (semplice app Hello World)

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

Esempio 2: restituire più widget + il pulsante stampa il testo dell'etichetta

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

Esempio 3: utilizzo di una classe (singolo widget) + il pulsante stampa "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()

Esempio 4: è lo stesso di ex. 2 ma mostra come usare una 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()

Con il linguaggio .kv

Esempio 5: lo stesso ma che mostra come usare il linguaggio kv all'interno di 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()

** Esempio 6: lo stesso con la parte kv in un file Tutorial.kv **

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

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

** Esempio 7: collegamento a un file kv specifico + un def in python che riceve label.text **

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

In myapp.kv: orientation: "vertical" Etichetta: id: mylabel text: "My App" Button: text: "Click me!" on_press: root.printMe (mylabel.text)

Esempio 8: il pulsante stampa il testo dell'etichetta (con un def in python usando ids (gli "ID"))

Notare che:

self_xx dall'esempio 7 è sostituito da self

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

In myapp.kv:

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

Esempio 9: il pulsante stampa il testo dell'etichetta (con un def in python usando StringProperty)

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

In Tutorial.kv:

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

Esempio 10: il pulsante stampa il testo dell'etichetta (con un def in python usando ObjectProperty)

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

In 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

Autorizzato sotto CC BY-SA 3.0

Non affiliato con Stack Overflow

kivy Tutorial
Iniziare con kivy

Ricerca…

Osservazioni

Installazione e configurazione

finestre

percorsi

Semplificalo

Tocca, afferra e muovi

Ciao mondo in kivy.

RecycleView

Diversi modi per eseguire una semplice app e interagire con i widget

Con il linguaggio .kv

Osservazioni

Installazione e configurazione

finestre

percorsi

Semplificalo

Tocca, afferra e muovi

Ciao mondo in kivy.

Esempio di popup semplice in Kivy.

RecycleView

Diversi modi per eseguire una semplice app e interagire con i widget

Con il linguaggio .kv