Table Of Contents

• Application
  • Creating an Application
    • Method using build() override
    • Method using kv file
  • Application configuration
    • Use the configuration file
    • Create a settings panel
  • Profiling with on_start and on_stop
  • Customising layout
  • Pause mode
  • Asynchronous app
    • Background
    • Async configuration
  • Interacting with Kivy app from other coroutines

Приложение

Класс App является базовым для создания приложений Kivy. Думайте о нем как о вашей основной точке входа в цикл выполнения Kivy. В большинстве случаев вы создаете подкласс этого класса и создаете свое собственное приложение. Вы создаете экземпляр вашего конкретного класса приложения, а затем, когда вы готовы начать жизненный цикл приложения, вызываете метод App.run() вашего экземпляра.

Создание приложения

Способ с использованием переопределения build()

Для инициализации вашего приложения с древом виджетов переопределите метод build() в вашем классе приложения и верните древо виджетов, которое вы построили.

Вот пример очень простого приложения, которое просто показывает кнопку:

'''
Application example using build() + return
==========================================

An application can be built if you return a widget on build(), or if you set
self.root.
'''

import kivy
kivy.require('1.0.7')

from kivy.app import App
from kivy.uix.button import Button


class TestApp(App):

    def build(self):
        # return a Button() as a root widget
        return Button(text='hello world')


if __name__ == '__main__':
    TestApp().run()

Файл также доступен в папке examples по следующему пути: kivy/examples/application/app_with_build.py.

Здесь не было создано древо виджетов (или, если хотите, дерево только с корневым узлом).

Способ с использованием файла kv

Вы также можете использовать Язык Kivy для создания приложений. В файле .kv можно одновременно содержать правила и определения корневых виджетов. Вот тот же пример, что и с кнопкой, описанный в файле kv.

Содержимое файла 'test.kv':

#:kivy 1.0

Button:
    text: 'Привет из test.kv'

Содержимое файла 'main.py':

'''

Application built from a  .kv file
==================================

This shows how to implicitly use a .kv file for your application. You
should see a full screen button labelled "Hello from test.kv".

After Kivy instantiates a subclass of App, it implicitly searches for a .kv
file. The file test.kv is selected because the name of the subclass of App is
TestApp, which implies that kivy should try to load "test.kv". That file
contains a root Widget.
'''

import kivy
kivy.require('1.0.7')

from kivy.app import App


class TestApp(App):
    pass


if __name__ == '__main__':
    TestApp().run()

См. kivy/examples/application/app_with_kv.py.

Связь между файлом main.py и test.kv объясняется в App.load_kv().

Настройка приложения

Использование файла конфигурации

Вашему приложению может потребоваться собственный файл конфигурации. Класс App автоматически обрабатывает файлы ‘ini’, если вы добавите пары ключ-значение секции в метод App.build_config(), используя параметр config (экземпляр класса ConfigParser):

class TestApp(App):
    def build_config(self, config):
        config.setdefaults('section1', {
            'key1': 'value1',
            'key2': '42'
        })

Как только вы добавите одну секцию в конфигурацию, на диске будет создан файл (см. get_application_config для его местоположения), и он будет назван на основе имени вашего класса. "TestApp" создаст файл конфигурации "test.ini" со следующим содержимым:

[section1]
key1 = value1
key2 = 42

Файл "test.ini" будет автоматически загружен во время выполнения, и вы сможете получить доступ к конфигурации в вашем методе App.build():

class TestApp(App):
    def build_config(self, config):
        config.setdefaults('section1', {
            'key1': 'value1',
            'key2': '42'
        })

    def build(self):
        config = self.config
        return Label(text='key1 is %s and key2 is %d' % (
            config.get('section1', 'key1'),
            config.getint('section1', 'key2')))

Создание панели настроек

Ваше приложение может иметь панель настроек, которая позволяет пользователю настроить некоторые из конфигурационных параметров. Вот пример, выполненный в примере KinectViewer (доступном в каталоге примеров):

Вы можете добавить собственные панели настроек, расширив метод App.build_settings(). Ознакомьтесь с Settings о том, как создать панель, потому что вам сначала потребуется файл JSON или данные.

Давайте возьмем в качестве примера предыдущий фрагмент TestApp с настройками по умолчанию. Мы могли бы создать JSON вот так:

[
    { "type": "title",
      "title": "Тестовое приложение" },

    { "type": "options",
      "title": "Мой первый ключ",
      "desc": "Описание моего первого ключа",
      "section": "section1",
      "key": "key1",
      "options": ["value1", "value2", "еще одно значение"] },

    { "type": "numeric",
      "title": "Мой второй ключ",
      "desc": "Описание моего второго ключа",
      "section": "section1",
      "key": "key2"  }
]

Затем мы можем создать панель, используя этот JSON, чтобы автоматически создать все параметры и связать их с нашим экземпляром ConfigParser из App.config:

class TestApp(App):
    # ...
    def build_settings(self, settings):
        jsondata = """... поместите сюда данные JSON ..."""
        settings.add_json_panel('Тестовое приложение',
            self.config, data=jsondata)

Вот и все! Теперь вы можете нажать F1 (клавиша по умолчанию), чтобы переключить панель настроек, или нажать клавишу "Настройки" на вашем устройстве Android. Вы можете также вручную вызвать App.open_settings() и App.close_settings(), если хотите управлять этим вручную. Все изменения в панели автоматически сохраняются в файле конфигурации.

Вы также можете использовать App.build_settings() для изменения свойств панели настроек. Например, в стандартной панели есть боковая панель для переключения между панелями JSON, ширина которой по умолчанию равна 200dp. Если вы хотите, чтобы она была уже, вы можете добавить следующее:

settings.interface.menu.width = dp(100)

в вашем методе build_settings().

Вам может потребоваться знать, когда пользователь изменил значение конфигурации, чтобы адаптировать или перезагрузить ваш пользовательский интерфейс. Тогда вы можете перегрузить метод on_config_change():

class TestApp(App):
    # ...
    def on_config_change(self, config, section, key, value):
        if config is self.config:
            token = (section, key)
            if token == ('section1', 'key1'):
                print('Наш key1 был изменен на', value)
            elif token == ('section1', 'key2'):
                print('Наш key2 был изменен на', value)

Панель настроек Kivy добавляется по умолчанию в экземпляр настроек. Если вы не хотите панель Kivy, вы можете объявить свое приложение следующим образом:

class TestApp(App):
    use_kivy_settings = False
    # ...

Это только удаляет панель Kivy, но не останавливает экземпляр настроек от появления. Если вы хотите вообще предотвратить появление экземпляра настроек совсем, вы можете сделать это так:

class TestApp(App):
    def open_settings(self, *largs):
        pass

Добавлено в версии 1.0.7.

Профилирование с помощью on_start и on_stop

Часто бывает полезно профилировать код на Python, чтобы найти места для оптимизации. Стандартная библиотека Python предоставляет несколько вариантов профилирования (http://docs.python.org/2/library/profile.html). Для профилирования всей программы естественные подходы, такие как использование profile как модуля или метода run модуля profile, не работают с Kivy. Однако можно использовать методы App.on_start() и App.on_stop():

import cProfile

class MyApp(App):
    def on_start(self):
        self.profile = cProfile.Profile()
        self.profile.enable()

    def on_stop(self):
        self.profile.disable()
        self.profile.dump_stats('myapp.profile')

Это создаст файл с именем myapp.profile при завершении вашего приложения.

Настройка макета

Вы можете выбирать различные настройки макета виджета, установив App.settings_cls. По умолчанию это класс Settings, который предоставляет изображенный макет боковой панели, но вы можете установить любой другой макет из предоставленных в kivy.uix.settings или создать свой собственный. Для получения дополнительной информации смотрите документацию модуля kivy.uix.settings.

Вы можете настраивать отображение панели настроек, переопределяя метод App.display_settings(), который вызывается перед отображением панели настроек на экране. По умолчанию он просто рисует панель поверх окна, но вы можете изменить его, например, чтобы показать настройки в виде Popup или добавить ее в свой ScreenManager, если вы используете его. Если вы это сделаете, вам также нужно будет изменить App.close_settings() для корректного закрытия панели. Например, чтобы панель настроек появлялась в виде всплывающего окна, вы можете сделать так:

def display_settings(self, settings):
    try:
        p = self.settings_popup
    except AttributeError:
        self.settings_popup = Popup(content=settings,
                                    title='Настройки',
                                    size_hint=(0.8, 0.8))
        p = self.settings_popup
    if p.content is not settings:
        p.content = settings
    p.open()

def close_settings(self, *args):
    try:
        p = self.settings_popup
        p.dismiss()
    except AttributeError:
        pass # Панель настроек не существует

Наконец, если вы хотите заменить текущий виджет панели настроек, вы можете удалить внутренние ссылки на него с помощью App.destroy_settings(). Если вы изменили App.display_settings(), будьте осторожны, чтобы обнаружить, была ли заменена панель настроек.

Режим паузы

Добавлено в версии 1.1.0.

На планшетах и телефонах пользователь может в любой момент переключиться на другое приложение. По умолчанию ваше приложение закроется, и событие App.on_stop() будет вызвано.

Если вы поддерживаете режим паузы, при переключении на другое приложение ваше приложение будет ожидать бесконечно, пока пользователь не вернется к вашему приложению. Есть проблема с OpenGL на устройствах Android: не гарантируется, что контекст OpenGL ES будет восстановлен, когда ваше приложение возобновится. Механизм восстановления всех данных OpenGL еще не реализован в Kivy.

В настоящее время реализованный механизм паузы следующий:

1. Kivy проверяет каждый кадр, активирован ли режим паузы операционной системой из-за переключения пользователя на другое приложение, выключения телефона или любой другой причины.

2. Вызывается App.on_pause():

3. Если возвращено False, вызывается App.on_stop().

4. Если возвращено True (по умолчанию), приложение засыпает до возобновления его операционной системой.

5. При возобновлении приложения вызывается App.on_resume().

6. Если память нашего приложения была освобождена операционной системой, то ничего не будет вызвано.

Вот простой пример того, как следует использовать on_pause():

class TestApp(App):

   def on_pause(self):
      # Здесь вы можете сохранить данные при необходимости
      return True

   def on_resume(self):
      # Здесь вы можете проверить, нужно ли что-то заменить (обычно ничего)
      pass

Предупреждение

И on_pause, и on_stop должны сохранять важные данные, потому что после вызова on_pause on_resume может вообще не вызываться.

Асинхронное приложение

Помимо обычного запуска приложения, Kivy может работать в асинхронном цикле событий, таком как предоставляемый стандартным библиотекой asyncio или библиотекой trio (настоятельно рекомендуется).

Фон

Обычно, когда запускается приложение Kivy, оно блокирует поток, в котором оно запущено, до выхода приложения. Внутренне, на каждой итерации такта часов выполнение всех колбэков приложения и обработка графики и ввода выполняется, а затем приложение переходит в режим ожидания, спящий на оставшееся время.

Для возможности асинхронного выполнения приложение Kivy не может спать, вместо этого оно должно освобождать управление контекстом выполнения асинхронного цикла событий, в котором запущено приложение Kivy. Это делается при простое путем вызова соответствующих функций пакета async, используемого вместо сна.

Настройка асинхронности

Для асинхронного запуска приложения Kivy необходимо запланировать выполнение корутины async_runTouchApp() или App.async_run() в цикле событий асинхронной библиотеки, используемой в данный момент.

Переменная окружения KIVY_EVENTLOOP или параметр async_lib в async_runTouchApp() и App.async_run() устанавливают асинхронную библиотеку, которую Kivy использует внутренне при запуске приложения с помощью async_runTouchApp() и App.async_run(). Он может быть установлен на одно из значений "asyncio", когда используется стандартная библиотека asyncio, или "trio", если используется библиотека trio. Если переменная окружения не установлена, а async_lib не предоставлена, будет использована стандартная библиотека asyncio.

Также можно непосредственно вызвать init_async_lib(), чтобы установить асинхронную библиотеку, но это можно сделать только до начала выполнения приложения с помощью async_runTouchApp() или App.async_run().

Для асинхронного запуска приложения необходимо запланировать выполнение async_runTouchApp() или App.async_run() в асинхронном цикле событий библиотеки, как показано в приведенных ниже примерах. Kivy будет обрабатываться как еще одна корутина, которую данная библиотека выполняет в своем цикле событий. Внутренне Kivy будет использовать API указанной асинхронной библиотеки, поэтому переменная окружения KIVY_EVENTLOOP или async_lib должны соответствовать асинхронной библиотеке, в которой работает Kivy.

Для получения более полных примеров основных и более сложных примеров см. демонстрационные приложения в examples/async.

Пример с asyncio ~~~~~~~~~~~~~~~~~

import asyncio

from kivy.app import async_runTouchApp
from kivy.uix.label import Label


loop = asyncio.get_event_loop()
loop.run_until_complete(
    async_runTouchApp(Label(text='Привет, мир!'), async_lib='asyncio'))
loop.close()

Пример с trio ~~~~~~~~~~~~~

import trio

from kivy.app import async_runTouchApp
from kivy.uix.label import Label

from functools import partial

# используйте functools.partial() для передачи ключевых аргументов:
async_runTouchApp_func = partial(async_runTouchApp, async_lib='trio')

trio.run(async_runTouchApp_func, Label(text='Привет, мир!'))

Взаимодействие с приложением Kivy из других корутин

Полностью безопасно взаимодействовать с любым объектом Kivy из других корутин, работающих в том же асинхронном цикле событий. Это происходит потому, что они все выполняются из одного и того же потока, и другие корутины выполняются только тогда, когда Kivy находится в режиме ожидания.

Точно так же обратные вызовы Kivy могут безопасно взаимодействовать с объектами из других корутин, работающих в том же цикле событий. На оба случая применяются нормальные правила для однопоточной работы.

Добавлено в версии 2.0.0.

class kivy.app.App(**kwargs)

Базовый класс: kivy.event.EventDispatcher

Класс приложения, см. документацию модуля для получения дополнительной информации.

Events

on_start:

Срабатывает при запуске приложения (перед вызовом runTouchApp()).

on_stop:

Срабатывает при завершении приложения.

on_pause:

Срабатывает, когда приложение приостанавливается операционной системой.

on_resume:

Срабатывает, когда приложение возобновляется после приостановки операционной системой. Важно: нет гарантии, что это событие будет срабатывать после того, как было вызвано событие on_pause.

Изменено в версии 1.7.0: Добавлен параметр kv_file.

Изменено в версии 1.8.0: Параметры kv_file и kv_directory теперь являются свойствами класса App.

async async_run(async_lib=None)

Идентичен методу run(), но является корутиной и может быть запланирован в работающем асинхронном цикле событий.

См. kivy.app для примеров использования.

Добавлено в версии 2.0.0.

build()

Инициализирует приложение; вызывается только один раз. Если этот метод возвращает виджет (дерево), он будет использоваться как корневой виджет и добавлен в окно.

Returns

None или экземпляр корневого Widget если self.root не существует.

build_config(config)

Добавлено в версии 1.0.7.

Этот метод вызывается перед инициализацией приложения для создания объекта ConfigParser. Здесь вы можете добавить любую секцию / ключ / значение по умолчанию для вашей конфигурации. Если что-либо установлено, конфигурация будет автоматически сохранена в файле, возвращенном get_application_config().

Parameters

config: ConfigParser

Используйте его, чтобы добавить элементы секции / ключа / значения по умолчанию

build_settings(settings)

Добавлено в версии 1.0.7.

Этот метод вызывается, когда пользователь (или вы) хотите показать настройки приложения. Он вызывается один раз, когда панель настроек впервые открывается, после чего панель кешируется. Он может быть вызван снова, если кешированная панель настроек удалена с помощью destroy_settings().

Вы можете использовать этот метод для добавления панелей настроек и настройки виджета настроек, например, изменив ширину боковой панели. См. документацию модуля для получения полной информации.

Parameters

settings: Settings

Экземпляр настроек для добавления панелей

close_settings(*largs)

Закрывает ранее открытую панель настроек.

Returns

True, если настройки были закрыты.

config

Возвращает экземпляр ConfigParser для конфигурации приложения. Вы можете использовать его для запроса некоторых конфигурационных токенов в методе build().

create_settings()

Создает панель настроек. Этот метод обычно вызывается только один раз в течение жизни приложения, и результат кешируется внутри, но его можно вызвать снова, если кешированная панель удалена с помощью destroy_settings().

По умолчанию он создает панель настроек в соответствии с settings_cls, вызывает build_settings(), добавляет панель Kivy, если use_kivy_settings равно True, и связывается с on_close/on_config_change.

Если вы хотите подключить свой собственный способ настройки, без панели Kivy или событий закрытия/изменения конфигурации, это то, что вам нужно перегрузить.

Добавлено в версии 1.8.0.

destroy_settings()

Добавлено в версии 1.8.0.

Ссылается на текущую панель настроек, если таковая имеется. Это означает, что при следующем запуске App.open_settings() будет создана и отображена новая панель. Это не влияет на содержание панели, но позволяет, например, обновить макет панели настроек, если вы изменили виджет настроек в ответ на изменение размеров экрана.

Если вы изменили open_settings() или display_settings(), вам следует быть внимательными, чтобы правильно определить, был ли уничтожен предыдущий виджет настроек.

property directory

Добавлено в версии 1.0.7.

Возвращает директорию, в котором находится приложение.

display_settings(settings)

Добавлено в версии 1.8.0.

Отображает панель настроек. По умолчанию панель отображается непосредственно поверх окна. Вы можете определить другое поведение, переопределив этот метод, например, добавив его в ScreenManager или Popup.

Вы должны вернуть True, если отображение успешно, в противном случае False.

Parameters

settings: Settings

Вы можете изменить этот объект, чтобы изменить отображение настроек.

get_application_config(defaultpath='%(appdir)s/%(appname)s.ini')

Возвращает имя файла конфигурации вашего приложения. В зависимости от платформы файл приложения будет храниться в разных местах:

• на iOS: <appdir>/Documents/.<appname>.ini

• на Android: <user_data_dir>/.<appname>.ini

• в противном случае: <appdir>/<appname>.ini

Когда вы распространяете ваше приложение на настольные компьютеры, обратите внимание, что если приложение предназначено для установки системно, пользователь может не иметь права на запись в каталог приложения. Если вы хотите хранить пользовательские настройки, вы должны перегрузить этот метод и изменить стандартное поведение для сохранения файла конфигурации в каталоге пользователя.

class TestApp(App):
    def get_application_config(self):
        return super(TestApp, self).get_application_config(
            '~/.%(appname)s.ini')

Несколько замечаний:

• Символ тильды ‘~’ будет расширен до каталога пользователя.

• %(appdir)s будет заменен на каталог приложения directory

• %(appname)s будет заменен на имя приложения name

Добавлено в версии 1.0.7.

Изменено в версии 1.4.0: Настроено стандартное расположение для платформ iOS и Android. Добавлен параметр defaultpath для настольных ОС (не применим к iOS и Android.)

Изменено в версии 1.11.0: Изменена версия Android для использования user_data_dir и добавлена недостающая точка в имени файла конфигурации iOS.

get_application_icon()

Возвращает значок приложения.

get_application_name()

Возвращает имя приложения.

static get_running_app()

Возвращает текущий запущенный экземпляр приложения.

Добавлено в версии 1.1.0.

icon

Значок вашего приложения. Значок может быть расположен в том же каталоге, что и ваш основной файл. Вы можете установить его следующим образом:

class MyApp(App):
    def build(self):
        self.icon = 'myicon.png'

Добавлено в версии 1.0.5.

Изменено в версии 1.8.0: icon теперь является StringProperty. Не устанавливайте значок в классе, как указано ранее в документации.

Заметка

Для Kivy до версии 1.8.0, вы должны установить это следующим образом:

class MyApp(App):
    icon = 'customicon.png'

Рекомендуется 256x256 или 1024x1024 для GNU/Linux и Mac OSX, 32x32 для Windows7 или ниже. <= 256x256 для Windows 8 256x256 работает (по крайней мере, на Windows 8), но масштабируется вниз и выглядит не так хорошо, как значок 32x32.

kv_directory

Путь к каталогу, в котором хранится kv-файл приложения, по умолчанию None

Добавлено в версии 1.8.0.

Если установлен kv_directory, он будет использоваться для получения начального kv-файла. По умолчанию предполагается, что файл находится в том же каталоге, что и текущий файл определения App.

kv_file

Имя файла Kv, который будет загружен, по умолчанию None.

Добавлено в версии 1.8.0.

Если установлен kv_file, он будет загружен при запуске приложения. Загрузка "default" kv-файла будет предотвращена.

load_config()

(внутренний) Эта функция используется для возврата ConfigParser с конфигурацией приложения. Она выполняет 3 действия:

1. Создание экземпляра ConfigParser

2. Загрузка конфигурации по умолчанию, вызывая build_config() , затем

3. Если существует, загрузка файла конфигурации приложения, в противном случае создание нового.

Returns

ConfigParser экземпляр

load_kv(filename=None)

Этот метод вызывается при первом запуске приложения, если не было построено дерево виджетов для этого приложения ранее. Затем этот метод ищет соответствующий файл kv в том же каталоге, что и файл, содержащий класс приложения.

Например, если у вас есть файл с именем main.py, который содержит:

class ShowcaseApp(App):
    pass

Этот метод будет искать файл с именем showcase.kv в каталоге, содержащем main.py. Имя файла kv должно быть в нижнем регистре именем класса без постфикса 'App' в конце, если он существует.

Вы можете определить правила и корневой виджет в вашем файле kv:

<ClassName>: # this is a rule
    ...

ClassName: # this is a root widget
    ...

Должен быть только один корневой виджет. Смотрите Документацию по языку Kivy для получения дополнительной информации о создании файлов kv. Если ваш файл kv содержит корневой виджет, он будет использоваться как self.root, корневой виджет для приложения.

Примечание

Эта функция вызывается из run() , поэтому любой виджет, стилизация которого определена в этом файле kv и создан до вызова run() (например, в __init__), не будет иметь примененных стилей. Обратите внимание, что build() вызывается после load_kv .

property name

New in version 1.0.7.

Возвращает имя приложения на основе имени класса.

on_config_change(config, section, key, value)

Обработчик событий, вызываемый при изменении токена конфигурации на странице настроек.

Изменено в версии 1.10.1: Добавлено соответствующее событие on_config_change.

on_pause()

Обработчик событий, вызываемый при запросе режима паузы. Вы должны возвращать True, если ваше приложение может перейти в режим паузы, в противном случае возвращайте False, и ваше приложение будет остановлено.

Вы не можете контролировать, когда приложение перейдет в этот режим. Это определяется операционной системой и в основном используется для мобильных устройств (android/ios) и для изменения размера окна.

Значение по умолчанию - True.

Добавлено в версии 1.1.0.

Изменено в версии 1.10.0: Значение по умолчанию теперь - True.

on_resume()

Обработчик событий, вызываемый, когда ваше приложение возобновляется из режима паузы.

Добавлено в версии 1.1.0.

Предупреждение

При возобновлении OpenGL Context может быть поврежден / освобожден. Здесь вы можете восстановить некоторое из вашего состояния OpenGL, например, содержимое FBO.

on_start()

Обработчик событий для события on_start, который вызывается после инициализации (после вызова build()) и перед началом выполнения приложения.

on_stop()

Обработчик событий для события on_stop, который вызывается, когда приложение завершило выполнение (т.е. окно собирается быть закрытым).

open_settings(*largs)

Открывает панель настроек приложения. Она будет создана в первый раз, или воссоздана, если ранее закешированная панель была удалена с помощью destroy_settings(). Панель настроек будет отображена с помощью метода display_settings(), который по умолчанию добавляет панель настроек к окну, привязанному к вашему приложению. Вы можете переопределить этот метод, если хотите отобразить панель настроек по-другому.

Returns

True, если настройки были открыты.

options

Опции, переданные в __init__ приложения

root

Виджет root, возвращенный методом build() или методом load_kv(), если файл kv содержит корневой виджет.

property root_window

Добавлено в версии 1.9.0.

Возвращает экземпляр корневого окна, используемый методом run().

run()

Запускает приложение в автономном режиме.

settings_cls

Добавлено в версии 1.8.0.

Класс, используемый для создания панели настроек и экземпляр, передаваемый в build_config(). Вы должны использовать либо Settings, либо один из предоставленных подклассов с разными макетами (SettingsWithSidebar, SettingsWithSpinner, SettingsWithTabbedPanel, SettingsWithNoMenu). Вы также можете создать свой собственный подкласс Settings. Для получения дополнительной информации смотрите документацию по Settings.

settings_cls является ObjectProperty и по умолчанию равен SettingsWithSpinner, который отображает панели настроек с помощью выпадающего списка для их переключения. Если вы устанавливаете строку, то будет использоваться Factory для разрешения класса.

stop(*largs)

Останавливает приложение.

Если вы используете этот метод, то всё приложение будет остановлено вызовом функции stopTouchApp().

title

Заголовок вашего приложения. Вы можете установить его следующим образом:

class MyApp(App):
    def build(self):
        self.title = 'Привет, мир!'

Добавлено в версии 1.0.5.

Изменено в версии 1.8.0: title теперь является StringProperty. Не устанавливайте заголовок в классе, как ранее указано в документации.

Примечание

Для Kivy < 1.8.0, вы можете установить заголовок следующим образом:

class MyApp(App):
    title = 'Пользовательский заголовок'

Если вы хотите динамически изменить заголовок, вы можете сделать следующее:

from kivy.base import EventLoop
EventLoop.window.title = 'Новый заголовок'

use_kivy_settings = True

Добавлено в версии 1.0.7.

Если True, настройки приложения также будут включать настройки Kivy. Если вы не хотите, чтобы пользователь изменял настройки Kivy из вашего интерфейса настроек, измените это значение на False.

property user_data_dir

Добавлено в версии 1.7.0.

Возвращает путь к директории в файловой системе пользователя, которую приложение может использовать для хранения дополнительных данных.

Разные платформы имеют разные соглашения относительно того, где пользователь может хранить данные, такие как настройки, сохраненные игры и настройки. Эта функция реализует эти соглашения. Директория <app_name> создается при вызове этого свойства, если она еще не существует.

На iOS возвращается ~/Documents/<app_name> (которая находится внутри песочницы приложения).

На Windows возвращается %APPDATA%/<app_name>.

На OS X возвращается ~/Library/Application Support/<app_name>.

На Linux возвращается $XDG_CONFIG_HOME/<app_name>.

На Android возвращается Context.GetFilesDir.

Изменено в версии 1.11.0: На Android, эта функция ранее возвращала /sdcard/<app_name>. Эта папка стала доступной только для чтения по умолчанию в Android API 26, и поэтому user_data_dir была перемещена в место для записи.

async kivy.app.async_runTouchApp(widget=None, embedded=False, async_lib=None)

Идентична функции runTouchApp(), но вместо этого это корутина, которую можно выполнить в существующем асинхронном цикле событий.

async_lib - это библиотека асинхронного кода, которую нужно использовать. Смотрите kivy.app для подробностей и примеров использования.

Добавлено в версии 2.0.0.

kivy.app.runTouchApp(widget=None, embedded=False)

Статическая главная функция, которая запускает цикл приложения. Вы можете получить доступ к некоторым магическим аргументам через:

Смотрите kivy.app для примеров использования.

Parameters

<empty>

Чтобы сделать диспетчеризацию событий, вам нужен хотя бы один слушатель событий ввода. В противном случае приложение завершит работу. (MTWindow действует как слушатель ввода)

widget

Если вы передаете только виджет, будет создан MTWindow и ваш виджет будет добавлен в окно как корневой виджет.

embedded

События не распространяются. Это будет вашей задачей.

widget + embedded

События не распространяются. Это будет вашей задачей, но мы попытаемся получить окно (которое должно быть создано вами заранее) и добавить виджет в него. Очень полезно для встраивания Kivy в другой инструментарий. (как, например, Qt, см. kivy-designed)

kivy.app.stopTouchApp()

Останавливает текущее приложение, выходя из главного цикла.

Смотрите kivy.app для примеров использования.

« Animation

Asynchronous data loader »