Kivy

https://kivy.org/doc/stable/
Admin
Kivy is an open source Python library for rapid development of applications with novel user...
Tokens:1,833,374
Snippets:12,709
Trust Score:10
Update:8 hours ago
Show doc for...
Tokens:
Raw
### Install kivy-examples (Ubuntu)

Source: https://kivy.org/doc/stable/installation/installation-linux.html

Optionally installs the gallery of examples.

```bash
sudo apt-get install kivy-examples
```

--------------------------------

### TuioMotionEventProvider.start method

Source: https://kivy.org/doc/stable/_modules/kivy/input/providers/tuio.html

Starts the TUIO provider by creating an OSCThreadServer, listening on the configured IP and port, and binding handlers for each OSC path. Requires the oscpy module; logs an info message and raises ImportError if it is not installed.

```python
    def start(self):
        '''Start the TUIO provider'''
        try:
            from oscpy.server import OSCThreadServer
        except ImportError:
            Logger.info(
                'Please install the oscpy python module to use the TUIO '
                'provider.'
            )
            raise
        self.oscid = osc = OSCThreadServer()
        osc.listen(self.ip, self.port, default=True)
        for oscpath in TuioMotionEventProvider.__handlers__:
            self.touches[oscpath] = {}
            osc.bind(oscpath, partial(self._osc_tuio_cb, oscpath))
```

--------------------------------

### Install Kivy from pre-compiled wheels

Source: https://kivy.org/doc/stable/gettingstarted/installation.html

Installs the current stable version of Kivy and kivy_examples from PyPi wheels. This also installs the minimum dependencies. For audio/video support, use 'kivy[base,media]' or 'kivy[full]'.

```bash
python -m pip install "kivy[base]" kivy_examples
```

--------------------------------

### SwapTransition __init__ and start methods

Source: https://kivy.org/doc/stable/_modules/kivy/uix/screenmanager.html

Initializes the SwapTransition and starts it. The start method sets up a scale transformation for each screen using PushMatrix, Scale, and PopMatrix groups, and binds the screen's center to update the scale origin.

```python
    def __init__(self, **kwargs):
        super(SwapTransition, self).__init__(**kwargs)
        self.scales = {}

    def start(self, manager):
        for screen in self.screen_in, self.screen_out:
            with screen.canvas.before:
                PushMatrix(group='swaptransition_scale')
                scale = Scale(group='swaptransition_scale')
            with screen.canvas.after:
                PopMatrix(group='swaptransition_scale')

            screen.bind(center=self.update_scale)
            self.scales[screen] = scale
        super(SwapTransition, self).start(manager)
```

--------------------------------

### Start and control video with play property

Source: https://kivy.org/doc/stable/api-kivy.uix.video.html

Shows how to start video playback at creation using the deprecated play property, and how to start it later by setting video.play = True. play is a BooleanProperty defaulting to False.

```python
# start playing the video at creation
video = Video(source='movie.mkv', play=True)

# create the video, and start later
video = Video(source='movie.mkv')
# and later
video.play = True
```

--------------------------------

### Install Python on Ubuntu using apt

Source: https://kivy.org/doc/stable/installation/installation-linux.html

Use apt to install Python3 and pip on Ubuntu. Run the update command first, then install the packages.

```bash
sudo apt-get update

sudo apt-get install -y \
    python3-pip \
    python3
```

--------------------------------

### Start and control video with state property

Source: https://kivy.org/doc/stable/api-kivy.uix.video.html

Shows how to start video playback at creation using the state property, and how to start it later by setting video.state = 'play'. state is an OptionProperty defaulting to 'stop'.

```python
# start playing the video at creation
video = Video(source='movie.mkv', state='play')

# create the video, and start later
video = Video(source='movie.mkv')
# and later
video.state = 'play'
```

--------------------------------

### Install Python via Homebrew

Source: https://kivy.org/doc/stable/guide/packaging-osx.html

Install Python using Homebrew. For Python 3, use 'brew install python3' and replace pip with pip3 in the guide.

```bash
$ brew install python
```

--------------------------------

### start(win, ctx)

Source: https://kivy.org/doc/stable/api-kivy.modules.console.html

Creates a Console instance attached to the given context and binds it to the Window's on_keyboard event for capturing keyboard shortcuts.

```APIDOC
## start(win, ctx)

### Description
Creates a Console instance attached to the given context and binds it to the Window's on_keyboard event for capturing keyboard shortcuts.

### Parameters
- **win** (Window) - Required - The application Window to bind to.
- **ctx** (Widget or subclass) - Required - The Widget to be inspected.
```

--------------------------------

### Install a wheel file with pip

Source: https://kivy.org/doc/stable/gettingstarted/installation.html

Use this command to install a pre-built wheel file directly. Replace the file name with the actual wheel file path. This example shows installing a Kivy wheel on Windows.

```bash
python -m pip install C:\Kivy-1.9.1.dev-cp27-none-win_amd64.whl
```

--------------------------------

### App._run_prepare method

Source: https://kivy.org/doc/stable/_modules/kivy/app.html

Internal method that prepares the app for running: builds the root widget, adds it to the window, sets the window title and icon, installs settings keys, and dispatches the on_start event. If no window is created, it logs a critical error and returns.

```python
    def _run_prepare(self):
        if not self.built:
            self.load_config()
            self.load_kv(filename=self.kv_file)
            root = self.build()
            if root:
                self.root = root
        if self.root:
            if not isinstance(self.root, Widget):
                Logger.critical('App.root must be an _instance_ of Widget')
                raise Exception('Invalid instance in App.root')
            from kivy.core.window import Window
            Window.add_widget(self.root)

        # Check if the window is already created
        from kivy.base import EventLoop
        window = EventLoop.window
        if window:
            self._app_window = window
            window.set_title(self.get_application_name())
            icon = self.get_application_icon()
            if icon:
                window.set_icon(icon)
            self._install_settings_keys(window)
        else:
            Logger.critical("Application: No window is created."
                            " Terminating application run.")
            return

        self.dispatch('on_start')
```

--------------------------------

### Slider value_normalized property with docstring examples

Source: https://kivy.org/doc/stable/_modules/kivy/uix/slider.html

Defines the value_normalized AliasProperty that maps the slider value to a 0-1 range. The docstring includes interactive examples showing how to get and set the normalized value.

```python
    value_normalized = AliasProperty(get_norm_value, set_norm_value,
                                     bind=('value', 'min', 'max'),
                                     cache=True)
    '''Normalized value inside the :attr:`range` (min/max) to 0-1 range::

        >>> slider = Slider(value=50, min=0, max=100)
        >>> slider.value
        50
        >>> slider.value_normalized
        0.5
        >>> slider.value = 0
        >>> slider.value_normalized
        0
        >>> slider.value = 100
        >>> slider.value_normalized
        1

    You can also use it for setting the real value without knowing the minimum
    and maximum::

        >>> slider = Slider(min=0, max=200)
        >>> slider.value_normalized = .5
        >>> slider.value
        100
        >>> slider.value_normalized = 1.
        >>> slider.value
        200

    :attr:`value_normalized` is an :class:`~kivy.properties.AliasProperty`.
    '''
```

--------------------------------

### TransitionBase.start()

Source: https://kivy.org/doc/stable/api-kivy.uix.screenmanager.html

Starts the transition.

```APIDOC
## TransitionBase.start()

### Description
Starts the transition.

### Method
`start()`
```

--------------------------------

### Start playing video at creation with play property (deprecated)

Source: https://kivy.org/doc/stable/_modules/kivy/uix/video.html

Shows how to use the deprecated play property to start playing the video immediately upon creation. Use state instead.

```python
# start playing the video at creation
video = Video(source='movie.mkv', play=True)
```

--------------------------------

### Install Twisted Reactor for Kivy

Source: https://kivy.org/doc/stable/_modules/kivy/support.html

This function installs a threaded-select Twisted reactor that integrates with Kivy's event loop. It prevents multiple installations, disables Twisted's signal handling by default, and schedules the reactor to start and stop with Kivy's EventLoop.

```python
    import twisted

    # prevent installing more than once
    if hasattr(twisted, '_kivy_twisted_reactor_installed'):
        return
    twisted._kivy_twisted_reactor_installed = True

    # don't let twisted handle signals, unless specifically requested
    kwargs.setdefault('installSignalHandlers', 0)

    # install threaded-select reactor, to use with own event loop
    from twisted.internet import _threadedselect
    _threadedselect.install()

    # now we can import twisted reactor as usual
    from twisted.internet import reactor
    from twisted.internet.error import ReactorNotRunning

    from collections import deque
    from kivy.base import EventLoop
    from kivy.logger import Logger
    from kivy.clock import Clock

    # will hold callbacks to twisted callbacks
    q = deque()

    # twisted will call the wake function when it needs to do work
    def reactor_wake(twisted_loop_next):
        '''Wakeup the twisted reactor to start processing the task queue
        '''

        Logger.trace("Support: twisted wakeup call to schedule task")
        q.append(twisted_loop_next)

    # called every frame, to process the reactors work in main thread
    def reactor_work(*args):
        '''Process the twisted reactor task queue
        '''
        Logger.trace("Support: processing twisted task queue")
        while len(q):
            q.popleft()()
    global _twisted_reactor_work
    _twisted_reactor_work = reactor_work

    # start the reactor, by telling twisted how to wake, and process
    def reactor_start(*args):
        '''Start the twisted reactor main loop
        '''
        Logger.info("Support: Starting twisted reactor")
        reactor.interleave(reactor_wake, **kwargs)
        Clock.schedule_interval(reactor_work, 0)

    # make sure twisted reactor is shutdown if eventloop exists
    def reactor_stop(*args):
        '''Shutdown the twisted reactor main loop
        '''
        if reactor.threadpool:
            Logger.info("Support: Stopping twisted threads")
            reactor.threadpool.stop()
        Logger.info("Support: Shutting down twisted reactor")
        reactor._mainLoopShutdown()
        try:
            reactor.stop()
        except ReactorNotRunning:
            pass

        import sys
        sys.modules.pop('twisted.internet.reactor', None)

    global _twisted_reactor_stopper
    _twisted_reactor_stopper = reactor_stop

    # start and stop the reactor along with kivy EventLoop
    Clock.schedule_once(reactor_start, 0)
    EventLoop.bind(on_stop=reactor_stop)
```

--------------------------------

### Example annotation file (.jsa)

Source: https://kivy.org/doc/stable/api-kivy.uix.videoplayer.html

A short example of a .jsa annotation file. It defines a list of label dictionaries with keys like start, duration, text, and bgcolor. The player automatically loads the associated annotation file if it exists.

```json
[
    {"start": 0, "duration": 2,
    "text": "This is an example of annotation"},
    {"start": 2, "duration": 2,
    "bgcolor": [0.5, 0.2, 0.4, 0.5],
    "text": "You can change the background color"}
]
```

--------------------------------

### Start playing video at creation with state property

Source: https://kivy.org/doc/stable/_modules/kivy/uix/video.html

Shows how to set the state property to 'play' to start playing the video immediately upon creation.

```python
# start playing the video at creation
video = Video(source='movie.mkv', state='play')
```

--------------------------------

### Animation.stop_all static method with example

Source: https://kivy.org/doc/stable/_modules/kivy/animation.html

Static method to stop all animations concerning a specific widget or list of properties. The docstring includes an example usage: create an Animation, start it on a widget, then call Animation.stop_all(widget, 'x') to stop the animation for that property.

```python
    @staticmethod
    def stop_all(widget, *largs):
        '''Stop all animations that concern a specific widget / list of
        properties.

        Example::

            anim = Animation(x=50)
            anim.start(widget)

            # and later
            Animation.stop_all(widget, 'x')
        '''
        if len(largs):
            for animation in list(Animation._instances):
                for x in largs:
                    animation.stop_property(widget, x)
        else:
            for animation in set(Animation._instances):
                animation.stop(widget)
```

--------------------------------

### KineticEffect usage example

Source: https://kivy.org/doc/stable/api-kivy.effects.kinetic.html

Shows the conceptual usage of KineticEffect: start, update, and stop a movement. The computed velocity is then accessed via the velocity property.

```python
>>> effect = KineticEffect()
>>> effect.start(10)
>>> effect.update(15)
>>> effect.update(30)
>>> effect.stop(48)
```

--------------------------------

### Create video and start later with state property

Source: https://kivy.org/doc/stable/_modules/kivy/uix/video.html

Shows how to create a video without starting it and then set the state property to 'play' later.

```python
# create the video, and start later
video = Video(source='movie.mkv')
# and later
video.state = 'play'
```

--------------------------------

### Animation.cancel_all static method with example

Source: https://kivy.org/doc/stable/_modules/kivy/animation.html

Static method to cancel all animations for a widget or list of properties. The docstring includes an example: create an Animation, start it, then call Animation.cancel_all(widget, 'x'). Since version 2.1.0, if widget is None, all animated widgets are targeted; if largs is given, only those properties are canceled.

```python
    @staticmethod
    def cancel_all(widget, *largs):
        '''Cancel all animations that concern a specific widget / list of
        properties. See :attr:`cancel`.

        Example::

            anim = Animation(x=50)
            anim.start(widget)

            # and later
            Animation.cancel_all(widget, 'x')

        .. versionadded:: 1.4.0

        .. versionchanged:: 2.1.0
            If the parameter ``widget`` is None, all animated widgets will be
            the target and cancelled. If ``largs`` is also given, animation of
            these properties will be canceled for all animated widgets.
        '''
        if widget is None:
            if largs:
                for animation in Animation._instances.copy():
                    for info in tuple(animation._widgets.values()):
                        widget = info['widget']
                        for x in largs:
                            animation.cancel_property(widget, x)
            else:
                for animation in Animation._instances:
                    animation._widgets.clear()
                    animation._clock_uninstall()
                Animation._instances.clear()
            return
        if len(largs):
            for animation in list(Animation._instances):
                for x in largs:
                    animation.cancel_property(widget, x)
        else:
            for animation in set(Animation._instances):
                animation.cancel(widget)
```

--------------------------------

### Calibration configuration examples for input devices

Source: https://kivy.org/doc/stable/_modules/kivy/input/postproc/calibration.html

Shows configuration examples for calibrating input devices using the [postproc:calibration] section. The first example maps device names to calibration parameters, the second shows provider-based matching with probesysfs, and the third applies calibration to all mtdev devices.

```ini
[input]
left = mtdev,/dev/input/event17
middle = mtdev,/dev/input/event15
# the right screen is just a display.
```

```ini
[postproc:calibration]
left = xratio=0.3333
middle = xratio=0.3333,xoffset=0.3333
```

```ini
[input]
mtdev_%(name)s = probesysfs,provider=mtdev
```

```ini
[postproc:calibration]
(mtdev) = xratio=0.3333,xoffset=0.3333
```

--------------------------------

### Kivy input configuration for mtdev provider

Source: https://kivy.org/doc/stable/_modules/kivy/input/providers/mtdev.html

Configuration example for the mtdev input provider in the Kivy configuration file. The first block shows a basic device setup with the format 'devicename = mtdev,/dev/input/eventXX'. The second block shows an example with inverted axes using the 'invert_x' and 'invert_y' options.

```ini
[input]
# devicename = hidinput,/dev/input/eventXX
acert230h = mtdev,/dev/input/event2
```

```ini
[input]
# example for inverting touch events
display = mtdev,/dev/input/event0,invert_x=1,invert_y=1
```

--------------------------------

### Settings demo application

Source: https://kivy.org/doc/stable/_modules/kivy/uix/settings.html

Example app demonstrating the Settings widget with a JSON panel and a color setting.

```python
if __name__ == '__main__':
    from kivy.app import App

    class SettingsApp(App):
        demo_json_settings = json.dumps([
            {
                'type': 'color',
                'title': 'Test color',
                'desc': 'Your chosen Color',
                'section': 'colorselection',
                'key': 'testcolor'
            }])

        def build(self):
            s = Settings()
            s.add_kivy_panel()
            s.add_json_panel('Color settings',
                             self.config,
                             data=self.demo_json_settings)
            s.bind(on_close=self.stop)
            return s

        def build_config(self, config):
            config.setdefaults('colorselection', {'testcolor': '#FF0000'})

    SettingsApp().run()
```

--------------------------------

### Install Buildozer and Initialize Project

Source: https://kivy.org/doc/stable/guide/packaging-osx.html

Install Buildozer via pip and initialize a new buildozer project. The buildozer.spec file must be edited to add app details and dependencies.

```bash
pip install git+http://github.com/kivy/buildozer
cd /to/where/I/Want/to/package
buildozer init
```

--------------------------------

### Check minimum Kivy version with kivy.require

Source: https://kivy.org/doc/stable/api-kivy.html

Use `kivy.require('1.0.1')` at the start of your application to ensure the installed Kivy version is at least 1.0.1. If the version is older, an Exception is raised.

```python
import kivy
kivy.require('1.0.1')
```

--------------------------------

### App.on_start()

Source: https://kivy.org/doc/stable/api-kivy.app.html

Called when the app is started.

```APIDOC
## App.on_start()

### Description
Called when the app is started.

### Method
on_start

### Signature
on_start(self)

### Example
```python
class MyApp(App):
    def on_start(self):
        print('App started')
```
```

--------------------------------

### Request a virtual keyboard with a custom layout

Source: https://kivy.org/doc/stable/api-kivy.uix.vkeyboard.html

Use Window.request_keyboard to get a keyboard widget, then set its layout to 'numeric.json' if a widget is available. This example assumes numeric.json is in the same directory as main.py.

```python
keyboard = Window.request_keyboard(
    self._keyboard_close, self)
if keyboard.widget:
    vkeyboard = self._keyboard.widget
    vkeyboard.layout = 'numeric.json'
```

--------------------------------

### Create camera and start later

Source: https://kivy.org/doc/stable/api-kivy.uix.camera.html

Creates a Camera widget with play=False (the default) and then starts it later by setting cam.play = True.

```python
# create the camera, and start later (default)
cam = Camera(play=False)
# and later
cam.play = True
```

--------------------------------

### Garden tool commands for package management

Source: https://kivy.org/doc/stable/api-kivy.garden.html

Commands to install, upgrade, uninstall, list, search, and get help for garden packages. The garden module does not initially include any packages.

```bash
# Installing a garden package
garden install graph

# Upgrade a garden package
garden install --upgrade graph

# Uninstall a garden package
garden uninstall graph

# List all the garden packages installed
garden list

# Search new packages
garden search

# Search all the packages that contain "graph"
garden search graph

# Show the help
garden --help
```

--------------------------------

### Cancel all animations for a property

Source: https://kivy.org/doc/stable/api-kivy.animation.html

Cancels all animations that concern a specific widget or list of properties. The example starts an animation on x and later cancels it. If widget is None, all animated widgets are targeted.

```python
anim = Animation(x=50)
anim.start(widget)

# and later
Animation.cancel_all(widget, 'x')
```

--------------------------------

### Get texture regions from an atlas

Source: https://kivy.org/doc/stable/api-kivy.graphics.texture.html

Loads a combined image and extracts four 64x64 regions using get_region(). The example assumes a 128x128 image containing four 64x64 images.

```python
# for example, load a 128x128 image that contain 4 64x64 images
from kivy.core.image import Image
texture = Image('mycombinedimage.png').texture

bottomleft = texture.get_region(0, 0, 64, 64)
bottomright = texture.get_region(0, 64, 64, 64)
topleft = texture.get_region(0, 64, 64, 64)
topright = texture.get_region(64, 64, 64, 64)
```

--------------------------------

### Example environment variable overrides

Source: https://kivy.org/doc/stable/_modules/kivy/config.html

Illustrates setting configuration values via environment variables, such as fullscreen mode and log level.

```text
KCFG_GRAPHICS_FULLSCREEN=auto ...
KCFG_KIVY_LOG_LEVEL=warning ...
```

--------------------------------

### kivy.eventmanager.MODE_DEFAULT_DISPATCH

Source: https://kivy.org/doc/stable/api-kivy.eventmanager.html

Constant for default dispatch mode: event dispatch through widget's children list, starting with the first widget until event gets accepted or last registered widget is reached.

```APIDOC
## kivy.eventmanager.MODE_DEFAULT_DISPATCH

### Description
Assign this mode to make event dispatch through widget's children list, starting with the first widget in the list until event gets accepted or last widget registered for that event is reached. Widgets after the last registered widget are ignored.

### Value
'default'

### Version
New in version 2.1.0.
```

--------------------------------

### Create video and start later with play property (deprecated)

Source: https://kivy.org/doc/stable/_modules/kivy/uix/video.html

Shows how to use the deprecated play property to start playing the video later. Use state instead.

```python
# create the video, and start later
video = Video(source='movie.mkv')
# and later
video.play = True
```

--------------------------------

### Camera Example: main.py

Source: https://kivy.org/doc/stable/examples/gen__camera__main__py.html

This is the full camera example from the Kivy documentation. It demonstrates using the Camera widget with a ToggleButton to control playback and a Button to capture a PNG image. The capture method uses the camera's export_to_png method with a timestamped filename. Note that not finding a camera, perhaps because gstreamer is not installed, will throw an exception during the kv language processing.

```python
'''
Camera Example
==============

This example demonstrates a simple use of the camera. It shows a window with
a buttoned labelled 'play' to turn the camera on and off. Note that
not finding a camera, perhaps because gstreamer is not installed, will
throw an exception during the kv language processing.

'''

# Uncomment these lines to see all the messages
# from kivy.logger import Logger
# import logging
# Logger.setLevel(logging.TRACE)

from kivy.app import App
from kivy.lang import Builder
from kivy.uix.boxlayout import BoxLayout
import time
Builder.load_string('''
<CameraClick>:
    orientation: 'vertical'
    Camera:
        id: camera
        resolution: (640, 480)
        play: False
    ToggleButton:
        text: 'Play'
        on_press: camera.play = not camera.play
        size_hint_y: None
        height: '48dp'
    Button:
        text: 'Capture'
        size_hint_y: None
        height: '48dp'
        on_press: root.capture()
''')


class CameraClick(BoxLayout):
    def capture(self):
        '''
        Function to capture the images and give them the names
        according to their captured time and date.
        '''
        camera = self.ids['camera']
        timestr = time.strftime("%Y%m%d_%H%M%S")
        camera.export_to_png("IMG_{}.png".format(timestr))
        print("Captured")


class TestCamera(App):

    def build(self):
        return CameraClick()


TestCamera().run()
```

--------------------------------

### TuioMotionEventProvider.start()

Source: https://kivy.org/doc/stable/api-kivy.input.providers.tuio.html

Starts the TUIO provider.

```APIDOC
## TuioMotionEventProvider.start()

### Description
Starts the TUIO provider.

### Method
`start()`

### Parameters
None explicitly documented.
```

--------------------------------

### Simple root widget example

Source: https://kivy.org/doc/stable/api-kivy.lang.html

A minimal .kv file with a root widget that displays 'Hello world'.

```kivy
#:kivy 1.0

Button:
    text: 'Hello world'

```

--------------------------------

### Run Kivy Catalog to test layout code

Source: https://kivy.org/doc/stable/guide/widgets.html

Commands to run the Kivy Catalog example, which allows you to test kv code interactively. Replace $KIVYDIR with the directory of your Kivy installation, which can be found using os.path.dirname(kivy.__file__).

```bash
cd $KIVYDIR/examples/demo/kivycatalog
python main.py
```

--------------------------------

### Kv file version header: #:kivy 1.0.9

Source: https://kivy.org/doc/stable/tutorials/pong.html

Required first line in every Kv file. Starts with #:kivy followed by a space and the Kivy version it is intended for, ensuring the installed Kivy version meets the requirement.

```kv
#:kivy 1.0.9
```

--------------------------------

### TransitionBase start method

Source: https://kivy.org/doc/stable/_modules/kivy/uix/screenmanager.html

Starts the transition. Raises ScreenManagerException if called twice. Sets up the animation, dispatches 'on_pre_enter' and 'on_pre_leave' events, and fires 'on_progress' with 0.

```python
[docs]    def start(self, manager):
        '''(internal) Starts the transition. This is automatically
        called by the :class:`ScreenManager`.
        '''
        if self.is_active:
            raise ScreenManagerException('start() is called twice!')
        self.manager = manager
        self._anim = Animation(d=self.duration, s=0)
        self._anim.bind(on_progress=self._on_progress,
                        on_complete=self._on_complete)

        self.add_screen(self.screen_in)
        self.screen_in.transition_progress = 0.
        self.screen_in.transition_state = 'in'
        self.screen_out.transition_progress = 0.
        self.screen_out.transition_state = 'out'
        self.screen_in.dispatch('on_pre_enter')
        self.screen_out.dispatch('on_pre_leave')

        self.is_active = True
        self._anim.start(self)
        self.dispatch('on_progress', 0)
```

--------------------------------

### Main block with ActionBar example

Source: https://kivy.org/doc/stable/_modules/kivy/uix/actionbar.html

Runs a touch app with a FloatLayout containing an ActionBar. It unregisters the ActionPrevious factory to avoid conflicts, loads a Kivy language string defining the ActionBar with buttons and groups, and starts the app.

```python
if __name__ == "__main__":
    from kivy.base import runTouchApp
    from kivy.uix.floatlayout import FloatLayout
    from kivy.factory import Factory

    # XXX clean the first registration done from '__main__' here.
    # otherwise kivy.uix.actionbar.ActionPrevious != __main__.ActionPrevious
    Factory.unregister('ActionPrevious')

    Builder.load_string('''
<MainWindow>:
    ActionBar:
        pos_hint: {'top':1}
        ActionView:
            use_separator: True
            ActionPrevious:
                title: 'Action Bar'
                with_previous: False
            ActionOverflow:
            ActionButton:
                text: 'Btn0'
                icon: 'atlas://data/images/defaulttheme/audio-volume-high'
            ActionButton:
                text: 'Btn1'
            ActionButton:
                text: 'Btn2'
            ActionGroup:
                text: 'Group 1'
                ActionButton:
                    text: 'Btn3'
                ActionButton:
                    text: 'Btn4'
            ActionGroup:
                dropdown_width: 200
                text: 'Group 2'
                ActionButton:
                    text: 'Btn5'
                ActionButton:
                    text: 'Btn6'
                ActionButton:
                    text: 'Btn7'
''')

    class MainWindow(FloatLayout):
        pass

    float_layout = MainWindow()
    runTouchApp(float_layout)
```

--------------------------------

### Create and run an InteractiveLauncher with a custom App

Source: https://kivy.org/doc/stable/api-kivy.interactive.html

Pass an existing App subclass instance to the InteractiveLauncher constructor and call run(). After pressing enter, the script returns, leaving the interpreter available. To test, start Python without a file and copy/paste the lines.

```python
from kivy.interactive import InteractiveLauncher
from kivy.app import App
from kivy.uix.button import Button

class MyApp(App):
    def build(self):
        return Button(text='Hello Shell')

launcher = InteractiveLauncher(MyApp())
launcher.run()
```

--------------------------------

### SwapTransition.start()

Source: https://kivy.org/doc/stable/api-kivy.uix.screenmanager.html

Starts the swap transition.

```APIDOC
## SwapTransition.start()

### Description
Starts the transition.

### Method
`start()`
```

--------------------------------

### Kivy Widget Animation Example (animation/animate.py)

Source: https://kivy.org/doc/stable/examples/gen__animation__animate__py.html

Complete Kivy app that animates a button on press. It creates an Animation object with sequential (+=) and parallel (&=) steps, then starts it on the button instance. Requires Kivy 1.0.7 or later.

```python
'''
Widget animation
================

This example demonstrates creating and applying a multi-part animation to
a button widget. You should see a button labelled 'plop' that will move with
an animation when clicked.
'''

import kivy
kivy.require('1.0.7')

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


class TestApp(App):

    def animate(self, instance):
        # create an animation object. This object could be stored
        # and reused each call or reused across different widgets.
        # += is a sequential step, while &= is in parallel
        animation = Animation(pos=(100, 100), t='out_bounce')
        animation += Animation(pos=(200, 100), t='out_bounce')
        animation &= Animation(size=(500, 500))
        animation += Animation(size=(100, 50))

        # apply the animation on the button, passed in the "instance" argument
        # Notice that default 'click' animation (changing the button
        # color while the mouse is down) is unchanged.
        animation.start(instance)

    def build(self):
        # create a button, and  attach animate() method as a on_press handler
        button = Button(size_hint=(None, None), text='plop',
                        on_press=self.animate)
        return button


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

```

--------------------------------

### Run Kivy demo on Windows

Source: https://kivy.org/doc/stable/gettingstarted/installation.html

Runs the Kivy showcase demo on Windows using the path to the examples directory.

```bash
python kivy_venv\share\kivy-examples\demo\showcase\main.py
```

--------------------------------

### Filter gestures by name using Recognizer.filter()

Source: https://kivy.org/doc/stable/api-kivy.multistroke.html

Shows how to use Recognizer.filter() with the 'name' argument to match gesture names using regular expressions. The examples match names starting with 'N', exactly 'N', and a list of patterns.

```python
gdb = Recognizer()

# Will match all names that start with a capital N
# (ie Next, New, N, Nebraska etc, but not "n" or "next")
gdb.filter(name='N')

# exactly 'N'
gdb.filter(name='N$')

# Nebraska, teletubbies, France, fraggle, N, n, etc
gdb.filter(name=['[Nn]', '(?i)T', '(?i)F'])
```

--------------------------------

### build()

Source: https://kivy.org/doc/stable/api-kivy.app.html

Initializes the application; called only once. If it returns a widget, it is used as the root widget and added to the window.

```APIDOC
## build()

### Description
Initializes the application; it will be called only once. If this method returns a widget (tree), it will be used as the root widget and added to the window.

### Returns
None or a root Widget instance if no self.root exists.
```

--------------------------------

### Create a simple Kivy app with build() override

Source: https://kivy.org/doc/stable/api-kivy.app.html

Subclass App, override build() to return a Button widget, and call run() to start the app. Requires kivy 1.0.7. The example file is also available at kivy/examples/application/app_with_build.py.

```python
'''
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()
```
Tokens:
Raw