Mise à jour du 20/06/2017
Il est apparu dans la traduction du manuel officiel. Après cela, apportez des corrections en utilisant les liens ci-dessous. Le correctif est compatible avec la dernière version 1.10 de kivy.
Une traduction de la référence API de Kivy Kivy Language. [Guide de programmation (traduit) »Langue Kv (traduit)" (https://pyky.github.io/kivy-doc-ja/guide/lang.html) a une explication qui n'est pas décrite, alors essayez de la traduire. J'ai fait.
Kivy Language
Module: kivy.langAdded in 1.0.0
Kivy Language est un langage dédié à la description des interfaces utilisateur et des interactions. Vous pouvez comparer ce langage avec QML de Qt (http://qt.nokia.com), mais il contient de nouveaux concepts tels que les définitions de règles (un peu comme CSS) et les modèles.
Modifié dans la version 1.7.0: Builder n'effectue pas de représentation de canevas en temps réel. Emballez toutes les expressions qui doivent être exécutées en premier, distribuez l'entrée et exécutez-les juste avant de dessiner le cadre. Si vous souhaitez forcer le dessin de canevas, appelez Builder.sync. . *
Inclut des outils de profilage expérimentaux pour kv lang. Vous pouvez l'activer en définissant la variable d'environnement KIVY_PROFILE_LANG = 1. Après cela, un fichier html nommé builder_stats.html sera généré. *
Kivy Language se compose de plusieurs configurations disponibles.
Rule La règle est similaire à la règle CSS. Les règles sont appliquées à un widget particulier (ou à sa classe) dans l'arborescence des widgets et sont modifiées d'une manière particulière. Vous pouvez utiliser des règles pour spécifier un comportement interactif et des règles pour ajouter une représentation graphique du widget que vous souhaitez appliquer. Vous pouvez utiliser l'attribut cls (par exemple cls = MyTestWidget) pour cibler une classe particulière de widget (similaire au concept CSS d'une classe).
Root Widget Vous pouvez utiliser Kivy Language pour créer l'intégralité de l'interface utilisateur. Le fichier kv doit contenir au plus un widget racine.
Dynamic Classes Dynamic Class (introduit dans la version 1.7.0) vous permet de créer rapidement de nouveaux widgets et règles sans déclaration côté fichier Python.
Templates (deprecated) (Introduit dans la version 1.0.5 et obsolète dans la version 1.7.0) Les modèles sont utilisés pour remplir des parties d'une application, telles que le contenu d'une liste de styles (par exemple, icône de gauche, texte de droite). J'ai fait. Déconseillé par classe dynamique.
Les fichiers Kivy Language ont une extension de fichier .kv.
Le contenu du fichier doit toujours commencer par l'en-tête Kivy. La version doit être remplacée par la version de Kivy Language que vous utilisez. Pour 1.0:
#:kivy `1.0`
# content here
Le contenu peut inclure des définitions de règle, des widgets racine, des définitions de classe dynamique et des modèles.
# Syntax of a rule definition. Note that several Rules can share the same
# definition (as in CSS). Note the braces: they are part of the definition.
<Rule1,Rule2>:
# .. definitions ..
<Rule3>:
# .. definitions ..
# Syntax for creating a root widget
RootClassName:
# .. definitions ..
# Syntax for creating a dynamic class
<NewWidget@BaseClass>:
# .. definitions ..
# Syntax for create a template
[TemplateName@BaseClass1,BaseClass2]:
# .. definitions ..
Qu'il s'agisse d'une règle, d'un widget racine, d'une classe dynamique ou d'un modèle que vous définissez, votre définition ressemble à ceci:
# With the braces it's a rule. Without them, it's a root widget.
<ClassName>:
prop1: value1
prop2: value2
canvas:
CanvasInstruction1:
canvasprop1: value1
CanvasInstruction2:
canvasprop2: value2
AnotherClass:
prop3: value1
Où * prop1 * et * prop2 * sont des propriétés de * ClassName * et * prop3 * sont des propriétés de * AnotherClass *. Si le widget n'a pas de propriété avec le nom spécifié, une propriété ObjectProperty est automatiquement créée et ajoutée au widget.
AnotherClass * est créé et ajouté en tant qu'enfant de l'instance * ClassName *.
L'indentation est importante et doit être cohérente. L'espace doit être un multiple de l'espace utilisé pour la première ligne en retrait. Il n'est pas recommandé de mélanger les onglets et les espaces.
La valeur de la propriété doit être indiquée sur une seule ligne (au moins pour l'instant).
Les propriétés du canevas sont spéciales. Vous pouvez représenter graphiquement la classe actuelle avec des instructions graphiques.
Voici un exemple simple de fichier kv contenant un widget racine.
#:kivy 1.0
Button:
text: 'Hello world'
Les méthodes load_file () et load_string () renvoient le widget racine défini dans le fichier / chaîne kv. Ajoutez également des définitions de classe et de modèle à Factory pour une utilisation ultérieure.
Si vous spécifiez une valeur pour une propriété, cette valeur est évaluée en tant qu'expression Python. Cette expression peut être statique ou dynamique. Autrement dit, vous pouvez utiliser des mots clés réservés pour utiliser les valeurs d'autres propriétés.
self Le mot clé self fait référence à "l'instance de widget actuelle":
Button:
text: 'My state is %s' % self.state
root Ce mot clé ne peut être utilisé que dans les définitions de règle et représente le widget racine de la règle (la première instance de la règle).
<MyWidget>:
custom: 'Hello world'
Button:
text: root.custom
app Ce mot clé fait toujours référence à votre instance d'application. Identique à l'appel de kivy.app.App.get_running_app () en Python.
Label:
text: app.name
args
Ce mot-clé peut être utilisé dans le rappel on_ \ <action >. Cela fait référence aux arguments passés au rappel.
TextInput:
on_focus: self.insert_text("Focus" if args[1] else "No focus")
ids
La définition de classe peut inclure un ID qui peut être utilisé comme mot clé.
<MyWidget>:
Button:
id: btn1
Button:
text: 'The state of the other button is %s' % btn1.state
Notez que cet * id * ne peut pas être utilisé avec une instance de widget. Il est utilisé exclusivement pour les références externes. * id * est une référence faible au widget, pas au widget lui-même. Le widget lui-même est accessible avec l'id .__ self__ (btn1 .__ self__ dans ce cas).
Lorsque le fichier kv est traité, une référence faible à tous les widgets marqués avec * id * est ajoutée au dictionnaire * ids * des widgets racine. En d'autres termes, en suivant l'exemple ci-dessus, vous pouvez accéder à l'état du bouton comme suit:
widget = MyWidget()
state = widget.ids["btn1"].state
# Or, as an alternative syntax,
state = widget.ids.btn1.state
Notez que le widget le plus à l'extérieur applique la kvRule à tous les widgets internes avant que les autres règles ne soient appliquées. Autrement dit, si votre widget interne contient des identifiants, ces identifiants peuvent ne pas être disponibles dans la fonction init de votre widget interne.
Il y a deux endroits dans le fichier kv pour accepter les instructions python. Après la propriété, le résultat de l'expression (comme le texte du bouton ci-dessous) et après on_property, la propriété est mise à jour (comme on_state).
Dans le premier cas, l'expression ne peut être que sur une seule ligne, les sauts de ligne ne peuvent pas être échappés et étendus à plusieurs lignes et la valeur doit être renvoyée. Des exemples d'expressions valides sont text: self.state et ('up' pour self.state == 'normal' else 'down').
Dans ce dernier cas, plusieurs instructions sur une seule ligne, y compris des instructions sur plusieurs lignes qui échappent aux sauts de ligne, sont valides sauf si vous ajoutez un niveau de retrait.
Voici un exemple de déclaration valide:
on_press: if self.state == 'normal': print('normal')
on_state:
if self.state == 'normal': print('normal')
else: print('down')
if self.state == 'normal': \
print('multiline normal')
for i in range(10): print(i)
print([1,2,3,4,
5,6,7])
Exemples d'instructions non valides:
on_state:
if self.state == 'normal':
print('normal')
Avec Kivy Language, vous pouvez voir que le travail se fait automatiquement dans les coulisses. Vous devez savoir que Properties implémente le modèle de conception d'observateur. Autrement dit, vous pouvez lier votre propre fonction pour qu'elle soit appelée lorsque la valeur de la propriété change (c'est-à-dire, observez passivement la propriété pour les changements potentiels).
Kivy Language crée un rappel de création pour détecter les propriétés d'une expression de valeur et mettre à jour automatiquement les propriétés via l'expression lorsque des modifications se produisent.
Voici un exemple simple de ce comportement.
Button:
text: str(self.state)
Dans cet exemple, l'analyseur détecte que self.state est une valeur dynamique (propriété). La propriété d'état du bouton peut être modifiée à tout moment (lorsque l'utilisateur le touche). Ce bouton doit afficher son propre état sous forme de texte, même si l'état change. Pour ce faire, utilisez la propriété d'état du bouton et utilisez-la pour la valeur de la propriété text du bouton. Cela contrôle le texte affiché sur le bouton (qui convertit également l'état en une représentation sous forme de chaîne). Les propriétés du texte sont automatiquement mises à jour chaque fois que l'état du bouton change.
Souvenez-vous. La valeur est une expression Python! Vous pouvez donc faire des choses intéressantes comme celle-ci:
Button:
text: 'Plop world' if self.state == 'normal' else 'Release me!'
Le texte du Button change avec l'état du Button. Par défaut, le texte du Button est "Plop world", mais lorsque vous appuyez sur le Button, le texte devient "Release me!".
Plus précisément, l'analyseur Kivy Language trouve toutes les sous-chaînes au format Xab où X est self ou root ou app ou un identifiant connu et a et b sont des propriétés. Ensuite, ajoutez et modifiez les dépendances appropriées. Par exemple, cela fonctionne comme prévu.
<IndexedExample>:
beta: self.a.b[self.c.d]
Cependant, en raison des restrictions d'analyseur attendues à l'avenir, vous ne pouvez pas:
<BadExample>:
beta: self.a.b[self.c.d].e.f
La partie .e.f ne suit certainement pas le modèle attendu et n'est pas reconnue car elle n'a pas les dépendances appropriées définies. Au lieu de cela, vous devez introduire une propriété intermédiaire pour autoriser les contraintes suivantes:
<GoodExample>:
alpha: self.a.b[self.c.d]
beta: self.alpha.e.f
Les instructions graphiques sont une partie spéciale du langage Kivy. Ils sont gérés par la définition de la propriété 'canvas':
Widget:
canvas:
Color:
rgb: (1, 1, 1)
Rectangle:
size: self.size
pos: self.pos
Toutes les classes ajoutées dans la propriété canvas doivent dériver de la classe Instruction. Vous ne pouvez pas placer la classe Widget dans la propriété canvas (le widget n'a pas de sens car il ne s'agit pas d'une instruction liée aux graphiques).
Si vous souhaitez profiter du thème, la même question que celle du CSS vous sera posée: quelle règle a été exécutée en premier? Dans ce cas, les règles sont exécutées dans l'ordre de traitement (de haut en bas).
Si vous souhaitez modifier la façon dont les boutons sont rendus, vous pouvez créer votre propre fichier kv et l'ajouter comme suit:
<Button>:
canvas:
Color:
rgb: (1, 0, 0)
Rectangle:
pos: self.pos
size: self.size
Rectangle:
pos: self.pos
size: self.texture_size
texture: self.texture
Cela fera apparaître un bouton avec un fond rouge étiqueté en bas à gauche, en plus de toutes les règles ci-dessus. Vous pouvez utiliser la commande * Effacer * pour effacer toutes les étapes précédentes.
<Button>:
canvas:
Clear
Color:
rgb: (1, 0, 0)
Rectangle:
pos: self.pos
size: self.size
Rectangle:
pos: self.pos
size: self.texture_size
texture: self.texture
Seules les règles suivant la commande * Effacer * sont prises en compte
Dynamic classes
La classe Dynamic vous permet de créer rapidement un nouveau widget sans utiliser au préalable une déclaration Python. La syntaxe de la classe dynamique est similaire à la règle, mais vous devez spécifier la classe de base à sous-classe.
La syntaxe est la suivante:
# Simple inheritance
<NewWidget@Button>:
# kv code here ...
# Multiple inheritance
<NewWidget@ButtonBehavior+Label>:
# kv code here ...
Le caractère @ est utilisé pour distinguer le nom de la classe de la classe de sous-classification. Combien coûte-t-il en Python.
# Simple inheritance
class NewWidget(Button):
pass
# Multiple inheritance
class NewWidget(ButtonBehavior, Label):
pass
Les nouvelles propriétés sont généralement ajoutées dans le code Python et doivent d'abord être déclarées. Si la propriété n'existe pas dans la classe Dynamic, elle sera automatiquement créée en tant que propriété ObjectProperty (antérieure à 1.8.0) ou propriété typée appropriée (à partir de 1.8.0).
Implémentons un bouton d'image de base et expliquons comment utiliser ces classes dynamiques. Il dérive simplement la classe de Button et ajoute la propriété de nom de fichier image.
<ImageButton@Button>:
source: None
Image:
source: root.source
pos: root.pos
size: root.size
# let's use the new classes in another rule:
<MainUI>:
BoxLayout:
ImageButton:
source: 'hello.png'
on_press: root.do_something()
ImageButton:
source: 'world.png'
on_press: root.do_something_else()
En Python, vous pouvez créer une instance d'une classe dynamique comme suit:
from kivy.factory import Factory
button_inst = Factory.ImageButton()
Note Les classes dynamiques permettent aux classes enfants d'être déclarées avant leur classe parent. Cependant, cela conduit à des situations non intuitives où la propriété / méthode parent remplace la propriété / méthode enfant. Soyez prudent si vous choisissez ce comportement.
Templates
Il y a deux choses que vous devez faire pour utiliser Template avec Kivy.
La syntaxe de Template est la suivante.
# With only one base class
[ClassName@BaseClass]:
# .. definitions ..
# With more than one base class
[ClassName@BaseClass1,BaseClass2]:
# .. definitions ..
Par exemple, pour une liste, vous devez créer une entrée avec une image à gauche et une étiquette à droite. Vous pouvez créer un modèle pour rendre la définition plus facile à utiliser. Par conséquent, créez un modèle qui utilise deux entrées dans le contexte. Le nom et le titre du fichier image sont les suivants.
[IconItem@BoxLayout]:
Image:
source: ctx.image
Label:
text: ctx.title
En Python, vous pouvez instancier un modèle comme suit:
from kivy.lang import Builder
# create a template with hello world + an image
# the context values should be passed as kwargs to the Builder.template
# function
icon1 = Builder.template('IconItem', title='Hello world',
image='myimage.png')
# create a second template with other information
ctx = {'title': 'Another hello world',
'image': 'myimage2.png'}
icon2 = Builder.template('IconItem', **ctx)
# and use icon1 and icon2 as other widget.
Dans la plupart des cas, vous utiliserez beaucoup de redéfinition lors de la création d'écrans en kv lang. Cet exemple crée une barre d'outils basée sur BoxLayout et place des widgets Image qui répondent à l'événement on_touch_down.
<MyToolbar>:
BoxLayout:
Image:
source: 'data/text.png'
size: self.texture_size
size_hint: None, None
on_touch_down: self.collide_point(*args[1].pos) and root.create_text()
Image:
source: 'data/image.png'
size: self.texture_size
size_hint: None, None
on_touch_down: self.collide_point(*args[1].pos) and root.create_image()
Image:
source: 'data/video.png'
size: self.texture_size
size_hint: None, None
on_touch_down: self.collide_point(*args[1].pos) and root.create_video()
Vous pouvez voir que les attributs size et size_hint sont exactement les mêmes. De plus, le rappel et l'image on_touch_down changent. Ce sont les parties variables du modèle qui peuvent être mises en contexte. Créons un modèle d'image:
[ToolbarButton@Image]:
# This is the same as before
size: self.texture_size
size_hint: None, None
# Now, we are using the ctx for the variable part of the template
source: 'data/%s.png' % ctx.image
on_touch_down: self.collide_point(*args[1].pos) and ctx.callback()
Les modèles peuvent être utilisés directement dans MyToolbarRule.
<MyToolbar>:
BoxLayout:
ToolbarButton:
image: 'text'
callback: root.create_text
ToolbarButton:
image: 'image'
callback: root.create_image
ToolbarButton:
image: 'video'
callback: root.create_video
C'est tout.
Lors de la création d'un contexte, procédez comme suit:
<MyRule>:
Widget:
id: mywidget
value: 'bleh'
Template:
ctxkey: mywidget.value # << fail, this references the id
# mywidget
<MyRule>:
Template:
ctxkey: 'value 1' if root.prop1 else 'value2' # << even if
# root.prop1 is a property, if it changes value, ctxkey
# will not be updated
Les définitions de modèle ne prennent pas en charge l'héritage car elles remplacent toute la définition portant le même nom.
Parfois, vous souhaitez hériter du widget afin d'utiliser les propriétés Python sans utiliser les styles de définition .kv. Par exemple, vous souhaitez hériter de Label, mais vous pouvez définir votre propre instruction de canevas au lieu d'utiliser automatiquement l'instruction de canevas héritée de Label. Cela peut être réalisé en ajoutant un tiret (-) au nom de la classe dans la définition de style .kv.
Dans myapp.py:
class MyWidget(Label):
pass
Puis dans my.kv:
<-MyWidget>:
canvas:
Color:
rgb: 1, 1, 1
Rectangle:
size: (32, 32)
MyWidget a maintenant des instructions de couleur et de rectangle dans le canevas sans utiliser les instructions héritées de Label.
Comme pour la redéfinition des styles, vous souhaiterez peut-être conserver tous les styles définis par KV et les hériter du widget, à l'exception des styles appliqués à certaines propriétés. Par exemple, vous voulez hériter de Button, mais vous pouvez définir votre propre * state_image * au lieu de vous fier aux valeurs de background_normal et background_down. Cela peut être réalisé en ajoutant un tiret (-) au nom de la propriété state_image dans la définition de style .kv.
Dans myapp.py
class MyWidget(Button):
new_background = StringProperty('my_background.png')
Et dans my.kv
<MyWidget>:
-state_image: self.new_background
MyWidget a maintenant un arrière-plan state_image défini uniquement avec new_background, et il est possible que state_image n'ait pas été défini dans les styles précédents.
Note L'ancienne règle a été effacée, mais elle sera appliquée lors de la création du widget et sera supprimée lorsque la nouvelle règle avec un tiret sera atteinte. Cela signifie que vous pouvez initialement définir les propriétés à l'aide de l'ancienne règle.
Les propriétés peuvent être initialisées dans KV et Python. Par exemple, en KV
<MyRule@Widget>:
text: 'Hello'
ramp: 45.
order: self.x + 10
MyRule () initialise les trois propriétés kivy à la valeur KV spécifiée. En dehors de Python, si la propriété existe déjà en tant que propriété kivy, vous pouvez utiliser une propriété telle que MyRule (* line = 'Bye', side = 55 *).
Mais qu'arrive-t-il à la valeur finale de la propriété lorsque MyRule (* text = 'Bye', order = 55 *) est exécutée? La règle rapide est que l'initialisation Python est plus forte par rapport à certaines règles que l'initialisation KV.
Plus précisément, le kwarg donné à l'initialiseur python est toujours appliqué en premier. Dans l'exemple ci-dessus, le texte est défini sur "Bye" et l'ordre est défini sur "55". Et toutes les règles KV s'appliquent, à l'exception des règles constantes qui remplacent les valeurs fournies par l'initialiseur Python.
Autrement dit, les KVRules qui ne créent pas de liaisons de type texte sont du texte: 'Hello' et rampe: 45. Si la valeur de cette propriété est fournie en Python, cette règle ne s'applique pas.
Ainsi, dans l'exemple MyRule (* text = 'Bye', order = 55 *), le texte est "Bye", la rampe est de 45 et l'ordre de création de la liaison est défini sur 55, mais KVRuleself.x + 10 Cela s'applique à tout.
Les directives vous permettent d'ajouter des commandes déclaratives telles que des importations et des définitions de constantes à votre fichier lang. La directive est ajoutée sous forme de commentaire au format suivant:
#:<directivename> <options>
import
** Ajouté dans la version 1.0.5. **
Comment écrire:
#:import <alias> <package>
Vous pouvez importer le package à décrire.
#:import os os
<Rule>:
Button:
text: os.getcwd()
Pour une écriture plus compliquée,
#:import ut kivy.utils
<Rule>:
canvas:
Color:
rgba: ut.get_random_color()
** Ajouté dans 1.0.7. **
Vous pouvez importer des classes directement depuis le module.
#: import Animation kivy.animation.Animation
<Rule>:
on_prop: Animation(x=.5).start(self)
set
** Ajouté dans 1.0.6. **
Comment écrire
#:set <key> <expr>
Définissez une clé qui peut être utilisée n'importe où dans kv. Par exemple:
#:set my_color (.4, .3, .4)
#:set my_color_hl (.5, .4, .5)
<Rule>:
state: 'normal'
canvas:
Color:
rgb: my_color if self.state == 'normal' else my_color_hl
include
grammaire:
#:include [force] <file>
Contient des fichiers Kivy externes. Cela vous permet de diviser un widget complexe en fichiers individuels. Lorsque include est forcé, le fichier est d'abord déchargé, puis rechargé. Par exemple:
# Test.kv
#:include mycomponent.kv
#:include force mybutton.kv
<Rule>:
state: 'normal'
MyButton:
MyComponent:
# mycomponent.kv
#:include mybutton.kv
<MyComponent>:
MyButton:
# mybutton.kv
<MyButton>:
canvas:
Color:
rgb: (1.0, 0.0, 0.0)
Rectangle:
pos: self.pos
size: (self.size[0]/4, self.size[1]/4)
API
class kivy.lang.Observable
Added in 1.9.0
Bases: kivy.event.ObjectWithUid
Observable est une classe stub qui définit les méthodes requises pour la liaison. EventDispatcher est un exemple de classe qui implémente l'interface de liaison. Voir EventDispatcher pour plus d'informations.
fbind()
Added in 1.9.0
Voir EventDispatcher.fbind ().
Note La méthode fbind () a été ajoutée pour maintenir la compatibilité descendante avec les classes dérivées qui peuvent avoir hérité de Observable. L'implémentation par défaut de fbind () consiste à créer une fonction partielle à passer à la liaison tout en préservant uid et largs / kwargs. Cependant, funbind () (et unbind_uid ()) doivent d'abord rechercher cette sous-fonction en utilisant largs / kwargs ou uid, puis appeler unbind () sur la fonction retournée, donc c'est à peu près C'est inefficace. Pour de meilleures performances, nous vous recommandons de remplacer ces méthodes par des classes dérivées pour la liaison directe. Similaire à EventDispatcher.fbind (), cette méthode renvoie 0 en cas d'échec et un uid unique positif en cas de succès. Cet uid peut être utilisé avec unbind_uid ().
## funbind()
Added in 1.9.0
fbind()Et EventDispatcher.funbind()S'il te plait regarde
## unbind_uid()
Added in 1.9.0
fbind()Et EventDispatcher.unbind_uid()S'il te plait regarde.
## class kivy.lang.BuilderBase
Added in 1.0.0
Bases: builtins.object
Le générateur analyse le fichier kv et crée un analyseur pour fusionner les résultats dans des règles internes, des modèles, etc.
Par défaut, le générateur est une instance Kivy globale utilisée par un widget qui peut lire d'autres fichiers kv en plus de celui par défaut.
## apply(widget, ignored_consts=set())
Added in 1.0.0
Recherchez et appliquez toutes les règles qui correspondent à votre widget.
*ignored_consts*Est un type d'ensemble ou de liste qui est un nom de propriété auquel la règle KV constante pour ce widget (c'est-à-dire la règle qui ne crée pas de liaison) ne s'applique pas. Cela évitera, par exemple, les règles constantes qui écrasent les valeurs initialisées en Python.
## apply_rules(widget, rule_name, ignored_consts=set())
Added in 1.9.2
rule_Trouvez toutes les règles qui correspondent au widget de nom et*widget*S'applique à.
*ignored_consts*Est un type d'ensemble ou de liste qui est un nom de propriété auquel la règle KV constante pour ce widget (c'est-à-dire la règle qui ne crée pas de liaison) ne s'applique pas. Cela évitera, par exemple, les règles constantes qui écrasent les valeurs initialisées en Python.
## load_file(filename, **kwargs)
Added in 1.0.0
Insère le fichier dans Language Builder et renvoie le widget racine (s'il est défini) pour le fichier kv.
**paramètre**：
rulesonly: tapez bool, la valeur par défaut est False.
Si True, Builder lève une exception s'il existe un widget racine dans la définition.
** load_string(string, **kwargs)
Added in 1.0.0
Insère la chaîne dans Language Builder et renvoie le widget racine (s'il est défini) pour la chaîne kv.
**paramètre**：
rulesonly: tapez bool, la valeur par défaut est False.
Si True, Builder lève une exception s'il existe un widget racine dans la définition.
** match(widget) Added in 1.0.0
Added in 1.0.0
Match widget*ParserRule*Renvoie une liste d'objets.
** match_rule_name(rule_name)
Added in 1.0.0
Match widget*ParserRule*Renvoie une liste d'objets.
** sync()
Added in 1.7.0
Effectue toutes les opérations d'attente, y compris l'exécution de toutes les expressions liées au canevas.
** template(*args, **ctx)
Added in 1.0.5
Créez un modèle spécial avec un contexte spécifique.
Le modèle vous permet de créer des widgets personnalisés à partir des définitions de kv lang. Vérifiez l'état d'utilisation du modèle.
## unbind_property(widget, name)
Added in 1.9.1
Dissocie le gestionnaire créé par toutes les règles du widget qui définit le nom.
Cela efface efficacement toutes les règles du widget qui prend la forme
**name: rule**
Exemple:
w = Builder.load_string(''' ... Widget: ... height: self.width / 2. if self.disabled else self.width ... x: self.y + 50 ... ''')
w.size [100, 100]
w.pos [50, 0]
w.width = 500 w.size [500, 500]
Builder.unbind_property(w, 'height') w.width = 222 w.size [222, 500]
w.y = 500 w.pos [550, 500]
** unbind_widget(uid)
Added in 1.7.2
Dissocie tous les gestionnaires créés par les règles KV du widget. Kivy parce que Builder l'utilise dans le destructeur du widget.uix.widget.Widget.L'uid est passé ici au lieu du widget lui-même.
Cela efface efficacement toutes les règles KV associées à ce widget.
Un exemple est le suivant.:
w = Builder.load_string(''' ... Widget: ... height: self.width / 2. if self.disabled else self.width ... x: self.y + 50 ... ''')
w.size [100, 100]
w.pos [50, 0]
w.width = 500 w.size [500, 500]
Builder.unbind_widget(w.uid) w.width = 222 w.y = 500 w.size [222, 500]
w.pos [50, 500]
## unload_file(filename)
Décharge toutes les règles associées aux fichiers précédemment importés.
Added in 1.0.8
## Warning
Cela ne supprime pas les règles ou les modèles déjà appliqués ou utilisés dans le widget actuel. Il n'affecte que la création des widgets ou appels aux modèles suivants.
## exception kivy.lang.BuilderException(context, line, message, cause=None)
Added in 1.0.0
Bases: kivy.lang.parser.ParserException
Une exception qui se produit lorsque le générateur ne parvient pas à appliquer une règle à un widget.
## class kivy.lang.Parser(**kwargs)
Added in 1.0.0
Bases: builtins.object
Créez un objet Parser qui analyse les fichiers Kivy Language ou le contenu Kivy.
## parse(content)
Added in 1.0.0
Analyse le contenu du fichier Parser et renvoie une liste d'objets racine.
## parse_level(level, lines, spaces=0)
Added in 1.0.0
Niveau actuel (niveau*Analysez l'indentation de (espace).
## strip_comments(lines)
Added in 1.0.0
Supprimez les commentaires sur toutes les lignes à la fois. Les commentaires doivent être écrits sur une seule ligne, pas à la fin de la ligne. Le premier caractère non vide de la ligne de commentaire doit être #.
## exception kivy.lang.ParserException(context, line, message, cause=None)
Added in 1.0.0
Bases: Exception
Exception qui se produit lorsque quelque chose ne va pas avec le fichier kv.