kivy Handledning => Komma igång med kivy

Anmärkningar

Kivy är ett Python-bibliotek med öppen källkod för snabb utveckling av användargränssnitt över plattformar. Kivy-applikationer kan utvecklas för Linux, Windows, OS X, Android och iOS med samma kodbas.

Grafik återges via OpenGL ES 2 snarare än via inbyggda widgets, vilket leder till ett ganska enhetligt utseende över operativsystem.

Att utveckla gränssnitt i Kivy involverar valfritt användning av kvlang, ett litet språk som stöder pythonliknande uttryck och python interop. Användningen av kvlang kan förenkla utvecklingen av användargränssnitt drastiskt jämfört med att använda Python exklusivt.

Kivy är gratis att använda (för närvarande under MIT-licensen) och professionellt stöttat.

Installation och installation

Windows

Det finns två alternativ för hur du installerar Kivy:

Se först till att pythonverktygen är uppdaterade.

python -m pip install --upgrade pip wheel setuptools

Installera sedan de grundläggande beroenden.

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

Även om Kivy redan har leverantörer för ljud och video krävs GStreamer för mer avancerade saker.

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

För att göra det enklare betyder <python> i följande text en sökväg till katalogen med filen python.exe .

Hjul
Hjulpaketet innehåller kompilerade Kivy, men med borttagna cython , vilket innebär att kärnkoden inte kan kompileras igen på detta sätt. Python-koden är emellertid redigerbar.
Den stabila versionen av Kivy finns på pypi.
```
python -m pip install kivy
```
Den senaste versionen från det officiella förvaret är tillgängligt via nattliga hjul som finns tillgängliga på Google Drive. Besök länken i dokument som matchar din Python-version. När ett ordentligt hjul har laddats ner, byt namn på det så att det matchar formateringen i detta exempel och kör kommandot.
```
python -m pip install C:\Kivy-1.9.1.dev-cp27-none-win_amd64.whl
```
Källa
Det krävs mer beroende för att installera Kivy från källan än att använda hjulen, men installationen är mer flexibel.
Skapa en ny fil i <python>\Lib\distutils\distutils.cfg med dessa rader för att säkerställa att en korrekt kompilator används för källkoden.
```
[build]
compiler = mingw32
```
Då behövs kompilatorn. Antingen använder du några som du redan har installerat eller ladda ner mingwpy . De viktiga filerna som gcc.exe kommer att finnas i <python>\Scripts .
```
python -m pip install -i https://pypi.anaconda.org/carlkl/simple mingwpy
```
Glöm inte att ställa in miljövariabler för att låta Kivy veta vilka leverantörer den ska använda.
```
set USE_SDL2=1
set USE_GSTREAMER=1
```
Installera nu de ytterligare beroenden som krävs för sammanställningen.
```
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/
```
Kontrollera avsnittet Paths att se till att allt är korrekt inställt och installera Kivy. Välj ett av dessa alternativ:
```
python -m pip install C:\master.zip
python -m pip install https://github.com/kivy/kivy/archive/master.zip
```

Paths

Kivy behöver tillgång till binärerna från vissa beroenden. Detta betyder att de korrekta mapparna måste vara på miljöns PATH variabel.

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

På detta sätt kan Python IDLE IDE inkluderas i sökvägen med <python>\Lib\idlelib; . Skriv sedan idle i konsolen och IDLE är redo att använda Kivy.

Förenkla det

För att undvika repetitiva inställningar av miljövariabler, ställ in varje nödvändig sökväg på detta sätt eller skapa en batchfil ( .bat ) med dessa rader placerade i <python> :

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

För att köra Kivy-projekt efter installationen kör cmd.exe eller batchfilen och använder python <filename>.py

installation på Ubuntu

För att installera kivy på ubuntu med kivy exempel öppna terminal och kör följande kommando

Lägg först till ppa

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

För installation kivy

 sudo apt-get install python-kivy

För installation av kivy-exempel

 sudo apt-get install python-kivy-example

Peka, ta och flytta

Följande exempel skapar en duk med 2 punkter och 1 rad mellan dem. Du kommer att kunna flytta punkten och linjen runt.

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

Hej värld i kivy.

Följande kod illustrerar hur man gör "hej världen" -app i kivy.Använda denna app i ios och android spara den som main.py och använda 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()

Följande kod illustrerar hur man gör enkel popup med 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()

Olika sätt att köra en enkel app och interagera med widgetar

De flesta kivy-appar börjar med den här strukturen:

from kivy.app import App

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

Det finns flera sätt att gå härifrån:

Alla koder nedan (utom exempel 1 och 3) har samma widget och liknande funktioner, men visar olika sätt att bygga appen på.

Exempel 1: returnera en enda widget (enkel 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()

Exempel 2: returnera flera widgetar + -knappen skriver ut etikettens text

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

Exempel 3: med en klass (enkel widget) + knappen skrivs ut "Min knapp"

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

Exempel 4: det är samma som ex. 2 men det visar hur man använder en klass

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

Med .kv-språk

Exempel 5: samma men visar hur man använder kv-språk inom 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()

** Exempel 6: samma sak med kv delen i en Tutorial.kv fil **

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

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

** Exempel 7: länk till specifik kv-fil + en def i python som tar emot etiketten.text **

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

I myapp.kv: orientering: "vertikal" Etikett: id: mylabel text: "Min app" -knapp: text: "Klicka på mig!" on_press: root.printMe (mylabel.text)

Exempel 8: knappen skriver ut etikettens text (med en def i python med ids ("ID: er"))

Lägg märke till att:

self_xx från exempel 7 ersätts av self

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

I myapp.kv:

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

Exempel 9: knappen skriver ut etikettens text (med en def i python med StringProperty)

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

I Tutorial.kv:

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

Exempel 10: knappen skriver ut etikettens text (med en def i python med hjälp av ObjectProperty)

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

I 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

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

kivy Handledning
Komma igång med kivy

Sök…

Anmärkningar

Installation och installation

Windows

Paths

Förenkla det

Peka, ta och flytta

Hej värld i kivy.

RecycleView

Olika sätt att köra en enkel app och interagera med widgetar

Med .kv-språk

Anmärkningar

Installation och installation

Windows

Paths

Förenkla det

Peka, ta och flytta

Hej värld i kivy.

Enkelt popup-exempel i Kivy.

RecycleView

Olika sätt att köra en enkel app och interagera med widgetar

Med .kv-språk